{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<small><small><i>\n",
    "All the IPython Notebooks in **Python Introduction** lecture series by **[Dr. Milaan Parmar](https://www.linkedin.com/in/milaanparmar/)** are available @ **[GitHub](https://github.com/milaan9/01_Python_Introduction)**\n",
    "</i></small></small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Namespace and Scope\n",
    "\n",
    "In this tutorial, you will learn about namespace, mapping from names to objects, and scope of a variable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is Name in Python?\n",
    "\n",
    "If you have ever read 'The Zen of Python' (type **`import this`** in the Python interpreter), the last line states, **Namespaces are one honking great idea -- let's do more of those!** So what are these mysterious namespaces? Let us first look at what name is.\n",
    "\n",
    "Name (also called identifier) is simply a name given to objects. Everything in Python is an **[object](https://github.com/milaan9/06_Python_Object_Class/blob/main/002_Python_Classes_and_Objects.ipynb)**. Name is a way to access the underlying object.\n",
    "\n",
    "For example, when we do the assignment **`a = 2`**, **`2`** is an object stored in memory and **`a`** is the name we associate it with. We can get the address (in RAM) of some object through the **[built-in function](https://github.com/milaan9/04_Python_Functions/tree/main/002_Python_Functions_Built_in)** **`id()`**. Let's look at how to use it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-22T17:09:01.664271Z",
     "start_time": "2021-06-22T17:09:01.657435Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id(9) = 140708960741424\n",
      "id(a) = 140708960741424\n"
     ]
    }
   ],
   "source": [
    "# Note: You may get different values for the id\n",
    "\n",
    "a = 9\n",
    "print('id(9) =', id(9))\n",
    "\n",
    "print('id(a) =', id(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, both refer to the same object **`9`**, so they have the same **`id()`**. Let's make things a little more interesting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-22T17:09:07.161795Z",
     "start_time": "2021-06-22T17:09:07.144217Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id(a) = 140708960741200\n",
      "id(a) = 140708960741232\n",
      "id(3) = 140708960741232\n",
      "id(b) = 140708960741200\n",
      "id(2) = 140708960741200\n"
     ]
    }
   ],
   "source": [
    "# Note: You may get different values for the id\n",
    "\n",
    "a = 2\n",
    "print('id(a) =', id(a))\n",
    "\n",
    "a = a+1\n",
    "print('id(a) =', id(a))\n",
    "\n",
    "print('id(3) =', id(3))\n",
    "\n",
    "b = 2\n",
    "print('id(b) =', id(b))\n",
    "print('id(2) =', id(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is happening in the above sequence of steps? Let's use a diagram to explain this:\n",
    "\n",
    "**Memory diagram of variables in Python**:\n",
    "\n",
    "<div>\n",
    "<img src=\"img/ns1.png\" width=\"500\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initially, an object **`2`** is created and the name a is associated with it, when we do **`a = a+1`**, a new object **`3`** is created and now a is associated with this object.\n",
    "\n",
    "Note that **`id(a)`** and **`id(3)`** have the same values.\n",
    "\n",
    "Furthermore, when **`b = 2`** is executed, the new name **`b`** gets associated with the previous object **`2`**.\n",
    "\n",
    "This is efficient as Python does not have to create a new duplicate object. This dynamic nature of name binding makes Python powerful; a name could refer to any type of object.\n",
    "\n",
    "```python\n",
    ">>>a = 5\n",
    ">>>a = 'Hello World!'\n",
    ">>>a = [1,2,3]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All these are valid and **`a`** will refer to three different types of objects in different instances. **[Functions](https://github.com/milaan9/04_Python_Functions/blob/main/001_Python_Functions.ipynb)** are objects too, so a name can refer to them as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-22T17:09:29.115275Z",
     "start_time": "2021-06-22T17:09:29.105508Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "def printHello():\n",
    "    print(\"Hello\")\n",
    "\n",
    "a = printHello\n",
    "\n",
    "a()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same name **`a`** can refer to a function and we can call the function using this name."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## What is a Namespace in Python?\n",
    "\n",
    "Now that we understand what names are, we can move on to the concept of namespaces.\n",
    "\n",
    "To simply put it, a namespace is a collection of names.\n",
    "\n",
    "In Python, you can imagine a namespace as a mapping of every name you have defined to corresponding objects.\n",
    "\n",
    "Different namespaces can co-exist at a given time but are completely isolated.\n",
    "\n",
    "A namespace containing all the built-in names is created when we start the Python interpreter and exists as long as the interpreter runs.\n",
    "\n",
    "This is the reason that built-in functions like **`id()`**, **`print()`** etc. are always available to us from any part of the program. Each **[module](https://github.com/milaan9/04_Python_Functions/blob/main/007_Python_Function_Module.ipynb)** creates its own global namespace.\n",
    "\n",
    "These different namespaces are isolated. Hence, the same name that may exist in different modules do not collide.\n",
    "\n",
    "Modules can have various functions and classes. A local namespace is created when a function is called, which has all the names defined in it. Similar, is the case with class. Following diagram may help to clarify this concept.\n",
    "\n",
    "<div>\n",
    "<img src=\"img/ns2.png\" width=\"300\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Variable Scope\n",
    "\n",
    "Although there are various unique namespaces defined, we may not be able to access all of them from every part of the program. The concept of scope comes into play.\n",
    "\n",
    "A scope is the portion of a program from where a namespace can be accessed directly without any prefix.\n",
    "\n",
    "At any given moment, there are at least three nested scopes.\n",
    "\n",
    "1. Scope of the current function which has local names\n",
    "2. Scope of the module which has global names\n",
    "3. Outermost scope which has built-in names\n",
    "\n",
    "When a reference is made inside a function, the name is searched in the local namespace, then in the global namespace and finally in the built-in namespace.\n",
    "\n",
    "If there is a function inside another function, a new scope is nested inside the local scope."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example of Scope and Namespace in Python\n",
    "\n",
    "```python\n",
    ">>>def outer_function():\n",
    ">>>    b = 30\n",
    ">>>    def inner_func():\n",
    ">>>        c = 60\n",
    "\n",
    ">>>a = 90\n",
    "```\n",
    "\n",
    "Here, the variable **`a`** is in the global namespace. Variable **`b`** is in the local namespace of **`outer_function()`** and **`c`** is in the nested local namespace of **`inner_function()`**.\n",
    "\n",
    "When we are in **`inner_function()`**, **`c`** is local to us, **`b`** is nonlocal and **`a`** is global. We can read as well as assign new values to **`c`** but can only read **`b`** and **`a`** from **`inner_function()`**.\n",
    "\n",
    "If we try to assign as a value to **`b`**, a new variable **`b`** is created in the local namespace which is different than the nonlocal **`b`**. The same thing happens when we assign a value to **`a`**.\n",
    "\n",
    "However, if we declare **`a`** as global, all the reference and assignment go to the global **`a`**. Similarly, if we want to rebind the variable **`b`**, it must be declared as nonlocal. The following example will further clarify this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-22T17:11:16.576081Z",
     "start_time": "2021-06-22T17:11:16.565338Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 60\n",
      "a = 30\n",
      "a = 90\n"
     ]
    }
   ],
   "source": [
    "def outer_function():\n",
    "    a = 30\n",
    "\n",
    "    def inner_function():\n",
    "        a = 60\n",
    "        print('a =', a)\n",
    "\n",
    "    inner_function()\n",
    "    print('a =', a)\n",
    "\n",
    "\n",
    "a = 90\n",
    "outer_function()\n",
    "print('a =', a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this program, three different variables **`a`** are defined in separate namespaces and accessed accordingly. While in the following program,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-22T17:11:21.608276Z",
     "start_time": "2021-06-22T17:11:21.588748Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 60\n",
      "a = 60\n",
      "a = 60\n"
     ]
    }
   ],
   "source": [
    "def outer_function():\n",
    "    global a\n",
    "    a = 30\n",
    "\n",
    "    def inner_function():\n",
    "        global a\n",
    "        a = 60\n",
    "        print('a =', a)\n",
    "\n",
    "    inner_function()\n",
    "    print('a =', a)\n",
    "\n",
    "\n",
    "a = 90\n",
    "outer_function()\n",
    "print('a =', a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, all references and assignments are to the global **`a`** due to the use of keyword **`global`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.9"
  },
  "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
}