Nested Statements & Scope in Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Nested Statements and Scope"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is important to understand how Python deals with the variable names we assign. When you create a variable name in Python the name is stored in a name-space. Variable names also have a scope, the scope determines the visibility of that variable name to other parts of your code.\n",
    "\n",
    "Lets try to understand it with below mentioned code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "A = 100\n",
    "\n",
    "def func():\n",
    "    A = 20\n",
    "    return A\n",
    "\n",
    "print A\n",
    "print func()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Question:\n",
    "\n",
    "1) What do you think the output of func() is 100 or 20 ? \n",
    "\n",
    "2) What is the output of print A is it 100 or 20 ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n"
     ]
    }
   ],
   "source": [
    "print A "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "print func()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Interesting! But how does Python know which A you're referring to in your code? This is where the idea of scope comes in. Python has a set of rules it follows to decide what variables (such as A in our case) you are referencing in your code. Lets break down the rules:\n",
    "\n",
    "This idea of scope in your code is very important to understand in order to properly assign and call variable names.\n",
    "\n",
    "In simple terms, the idea of scope can be described by 3 general rules:\n",
    "\n",
    "1) Name assignments will create or change local names by default.\n",
    "2) Name references search (at most) four scopes, these are:\n",
    "    2.a) local\n",
    "    2.b) enclosing functions\n",
    "    2.c) global\n",
    "    2.d) built-in\n",
    "3) Names declared in global and nonlocal statements map assigned names to enclosing module and function scopes.\n",
    "The statement in #2 above can be defined by the LEGB rule.\n",
    "\n",
    "## LEGB Rule:\n",
    "\n",
    "L: Local — Names assigned in any way within a function , and not declared global in that function.\n",
    "\n",
    "E: Enclosing function locals — Name in the local scope of any and all enclosing functions, from inner to outer.\n",
    "\n",
    "G: Global (module) — Names assigned at the top-level of a module file, or declared global in a def within the file.\n",
    "\n",
    "B: Built-in (Python) — Names preassigned in the built-in names module : open,range,SyntaxError,..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Let Us Understand LEGB with Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "# Any variable defined inside a function is called as Local\n",
    "\n",
    "def print_val():\n",
    "    val = 10\n",
    "    print(val)\n",
    "\n",
    "print_val()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In above example \"val\" is a local variable "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Enclosing Function Local"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This occurs when we have a function inside a function (nested functions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Sabby\n"
     ]
    }
   ],
   "source": [
    "name = 'OUR GLOBAL NAME'\n",
    "\n",
    "def welcome():\n",
    "    # Enclosing function\n",
    "    name = 'Sabby'\n",
    "    \n",
    "    def hello():\n",
    "        print 'Hello '+name\n",
    "    \n",
    "    hello()\n",
    "\n",
    "welcome()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note how Sabby was used, because the hello() function was enclosed inside of the hello function!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Global"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OUR GLOBAL NAME\n"
     ]
    }
   ],
   "source": [
    "print name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Built-in\n",
    "These are the built-in function names in Python (don't overwrite these!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function len>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "type"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Local Variable "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you declare variables inside a function definition, they are not related in any way to other variables with the same names used outside the function - i.e. variable names are local to the function. This is called the scope of the variable. All variables have the scope of the block they are declared in starting from the point of definition of the name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "z is 50\n",
      "Changed local z to 2\n",
      "z is still 50\n"
     ]
    }
   ],
   "source": [
    "z = 50\n",
    "\n",
    "def func(z):\n",
    "    print 'z is', z\n",
    "    z = 2\n",
    "    print 'Changed local z to', z\n",
    "\n",
    "func(z)\n",
    "print 'z is still', z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first time that we print the value of the name z with the first line in the function’s body, Python uses the value of the parameter declared in the main block, above the function definition.\n",
    "\n",
    "Next, we assign the value 2 to z. The name z is local to our function. So, when we change the value of z in the function, the z defined in the main block remains unaffected.\n",
    "\n",
    "With the last print statement, we display the value of z as defined in the main block, thereby confirming that it is actually unaffected by the local assignment within the previously called function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Global Statement\n",
    "\n",
    "If you want to assign a value to a name defined at the top level of the program (i.e. not inside any kind of scope such as functions or classes), then you have to tell Python that the name is not local, but it is global. We do this using the global statement. It is impossible to assign a value to a variable defined outside a function without the global statement.\n",
    "\n",
    "You can use the values of such variables defined outside the function (assuming there is no variable with the same name within the function). However, this is not encouraged and should be avoided since it becomes unclear to the reader of the program as to where that variable’s definition is. Using the global statement makes it amply clear that the variable is defined in an outermost block."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before calling func(), y is:  50\n",
      "This function is now using the global y!\n",
      "Because of global y is:  50\n",
      "Ran func(), changed global y to 2\n",
      "Value of y (outside of func()) is:  2\n"
     ]
    }
   ],
   "source": [
    "y = 50\n",
    "\n",
    "def func():\n",
    "    global y\n",
    "    print 'This function is now using the global y!'\n",
    "    print 'Because of global y is: ', y\n",
    "    y = 2\n",
    "    print 'Ran func(), changed global y to', y\n",
    "\n",
    "print 'Before calling func(), y is: ', y\n",
    "func()\n",
    "print 'Value of y (outside of func()) is: ', y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The global statement is used to declare that y is a global variable - hence, when we assign a value to y inside the function, that change is reflected when we use the value of y in the main block.\n",
    "\n",
    "we can specify more than one global variable using the same global statement e.g. global x, y, z."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}