Global and Local Scope.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "66223a6d",
   "metadata": {},
   "source": [
    "### Global and Local Scopes\n",
    "#### In Python the global scope refers to the module scope.\n",
    "\n",
    "#### The scope of a variable is normally defined by where it is (lexically) defined in the code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1b000b36",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b37db6ee",
   "metadata": {},
   "source": [
    "In this case, a is defined inside the main module, so it is a global variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1ef44150",
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_func(n):\n",
    "    c = n ** 2\n",
    "    return c"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3f1d864",
   "metadata": {},
   "source": [
    "In this case, c was defined inside the function my_func, so it is local to the function my_func. In this example, n is also local to my_func\n",
    "\n",
    "Global variables can be accessed from any inner scope in the module, for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "652a0008",
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_func(n):\n",
    "    print('global:', a)\n",
    "    c = a ** n\n",
    "    return c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7c80996d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "global: 10\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_func(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f48e02bc",
   "metadata": {},
   "source": [
    "As you can see, my_func was able to reference the global variable a.\n",
    "\n",
    "But remember that the scope of a variable is determined by where it is assigned. In particular, any variable defined (i.e. assigned a value) inside a function is local to that function, even if the variable name happens to be global too!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "50a8f2cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_func(n):\n",
    "    a = 2\n",
    "    c = a ** 2\n",
    "    return c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b0bd9853",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "4\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "print(my_func(3))\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f662e11",
   "metadata": {},
   "source": [
    "### In order to change the value of a global variable within an inner scope, we can use the global keyword as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4d69cb53",
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_func(n):\n",
    "    global a\n",
    "    a = 2\n",
    "    c = a ** 2\n",
    "    return c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b348ae03",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "4\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "print(my_func(3))\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a1e3442",
   "metadata": {},
   "source": [
    "### As you can see, the value of the global variable a was changed from within my_func.\n",
    "\n",
    "#### In fact, we can create global variables from within an inner function - Python will simply create the variable and place it in the global scope instead of the local scope:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "cfb214dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_func(n):\n",
    "    global var\n",
    "    var = 'hello world'\n",
    "    return n ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04a64574",
   "metadata": {},
   "source": [
    "Now, var does not exist yet, since the function has not run"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "40b22c9a",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'var' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[10], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mvar\u001b[49m)\n",
      "\u001b[1;31mNameError\u001b[0m: name 'var' is not defined"
     ]
    }
   ],
   "source": [
    "print(var)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "9fbe92c0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_func(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "f4e5a051",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "print(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "116aef7a",
   "metadata": {},
   "source": [
    "Remember that whenever you assign a value to a variable without having specified the variable as global, it is local in the current scope. Moreover, it does not matter where the assignment in the code takes place, the variable is considered local in the entire scope - Python determines the scope of objects at compile-time, not at run-time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "bdaa8abc",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10\n",
    "b = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "345bd0b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_func():\n",
    "    print(a)\n",
    "    print(b)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "0dbe3745",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "my_func()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7ed7cb6",
   "metadata": {},
   "source": [
    "So, this works as expected - a and b are taken from the global scope since they are referenced before being assigned a value in the local scope.\n",
    "\n",
    "But now consider the following example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "03e9bb7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10\n",
    "b = 100\n",
    "\n",
    "def my_func():\n",
    "    print(a)\n",
    "    print(b)\n",
    "    b = 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "647ccbb5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    },
    {
     "ename": "UnboundLocalError",
     "evalue": "local variable 'b' referenced before assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mUnboundLocalError\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[17], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mmy_func\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[1;32mIn[16], line 6\u001b[0m, in \u001b[0;36mmy_func\u001b[1;34m()\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mmy_func\u001b[39m():\n\u001b[0;32m      5\u001b[0m     \u001b[38;5;28mprint\u001b[39m(a)\n\u001b[1;32m----> 6\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[43mb\u001b[49m)\n\u001b[0;32m      7\u001b[0m     b \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1000\u001b[39m\n",
      "\u001b[1;31mUnboundLocalError\u001b[0m: local variable 'b' referenced before assignment"
     ]
    }
   ],
   "source": [
    "my_func()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4aa5bb09",
   "metadata": {},
   "source": [
    "As you can see, b in the line print(b) is considered a local variable - that's because the next line assigns a value to b - hence b is scoped as local by Python for the entire function.\n",
    "\n",
    "Of course, functions are also objects, and scoping applies equally to function objects too. For example, we can \"mask\" the built-in print Python function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "9f71db4e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello world!'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print = lambda x: 'hello {0}!'.format(x)\n",
    "\n",
    "def my_func(name):\n",
    "\treturn print(name)\n",
    "\n",
    "my_func('world')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "034b768b",
   "metadata": {},
   "source": [
    "You may be wondering how we get our real print function back."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "2f2a6e33",
   "metadata": {},
   "outputs": [],
   "source": [
    "del print"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "a3a724d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "print('hello')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0045946",
   "metadata": {},
   "source": [
    "If you have experience in some other programming languages you may be wondering if loops and other code \"blocks\" have their own local scope too. For example in Java, the following would not work:\n",
    "\n",
    "for (int i=0; i<10; i++) { int x = 2 * i; } system.out.println(x);\n",
    "\n",
    "But in Python it works perfectly fine:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "ce2ddc9b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    x = 2 * i\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c356cace",
   "metadata": {},
   "source": [
    "In this case, when we assigned a value to x, Python put it in the global (module) scope, so we can reference it after the for loop has finished running."
   ]
  }
 ],
 "metadata": {
  "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}