1-Learn-Python/04-List-Comprehensions-and-args-kwargs-and-Scope(LEGB).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# List Comprehensions - Simple way to build the list\n",
    "\n",
    "In addition to sequence operations and list methods, Python includes a more advanced operation called a list comprehension.\n",
    "\n",
    "List comprehensions allow us to build out lists using a different notation. You can think of it as essentially a one line <code>for</code> loop built inside of brackets. For a simple example:\n",
    "## Example 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Grab every letter in string\n",
    "lst = [x for x in 'word']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['w', 'o', 'r', 'd']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check\n",
    "lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the basic idea of a list comprehension. If you're familiar with mathematical notation this format should feel familiar for example:{ x^2 : x belongs to (0,1,2...10) } \n",
    "\n",
    "Let's see a few more examples of list comprehensions in Python:\n",
    "## Example 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Square numbers in range and turn into list\n",
    "lst = [x**2 for x in range(0,11)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 3\n",
    "Let's see how to add in <code>if</code> statements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check for even numbers in a range\n",
    "lst = [x for x in range(11) if x % 2 == 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8, 10]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 4\n",
    "Can also do more complicated arithmetic:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[32.0, 50.0, 68.18, 94.1]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Convert Celsius to Fahrenheit\n",
    "celsius = [0,10,20.1,34.5]\n",
    "\n",
    "fahrenheit = [((9/5)*temp + 32) for temp in celsius ]\n",
    "\n",
    "fahrenheit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 5\n",
    "We can also perform nested list comprehensions, for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 16, 81, 256, 625, 1296, 2401, 4096, 6561, 10000]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst = [ x**2 for x in [x**2 for x in range(11)]]\n",
    "lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Later on we will learn about generator comprehensions. After this  you should feel comfortable reading and writing basic list comprehensions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 'ODD', 2, 'ODD', 4, 'ODD', 6, 'ODD', 8, 'ODD']\n"
     ]
    }
   ],
   "source": [
    "# using if-else in list comprehension\n",
    "listi = [x if x%2==0 else \"ODD\" for x in range(10)]\n",
    "print(listi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `*args` and `**kwargs`\n",
    "\n",
    "Work with Python long enough, and eventually you will encounter `*args` and `**kwargs`. These strange terms show up as parameters in function definitions. What do they do? Let's review a simple function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "def myfunc(a,b):\n",
    "    return sum((a,b))*.05\n",
    "\n",
    "myfunc(40,60)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function returns 5% of the sum of `a` and `b`. In this example, `a` and `b` are *positional* arguments; that is, 40 is assigned to `a` because it is the first argument, and 60 to `b`. Notice also that to work with multiple positional arguments in the `sum()` function we had to pass them in as a tuple.\n",
    "\n",
    "What if we want to work with more than two numbers? One way would be to assign a *lot* of parameters, and give each one a default value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def myfunc(a=0,b=0,c=0,d=0,e=0):\n",
    "    return sum((a,b,c,d,e))*.05\n",
    "\n",
    "myfunc(40,60,20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obviously this is not a very efficient solution, and that's where `*args` comes in.\n",
    "\n",
    "## `*args`\n",
    "\n",
    "When a function parameter starts with an asterisk, it allows for an *arbitrary number* of arguments, and the function takes them in as a tuple of values. Rewriting the above function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def myfunc(*args):\n",
    "    return sum(args)*.05\n",
    "\n",
    "myfunc(40,60,20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how passing the keyword \"args\" into the `sum()` function did the same thing as a tuple of arguments.\n",
    "\n",
    "It is worth noting that the word \"args\" is itself arbitrary - any word will do so long as it's preceded by an asterisk. To demonstrate this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def myfunc(*spam):\n",
    "    return sum(spam)*.05\n",
    "\n",
    "myfunc(40,60,20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `**kwargs`\n",
    "\n",
    "Similarly, Python offers a way to handle arbitrary numbers of *keyworded* arguments. Instead of creating a tuple of values, `**kwargs` builds a dictionary of key/value pairs. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My favorite fruit is pineapple\n"
     ]
    }
   ],
   "source": [
    "def myfunc(**kwargs):\n",
    "    if 'fruit' in kwargs:\n",
    "        print(f\"My favorite fruit is {kwargs['fruit']}\")\n",
    "    else:\n",
    "        print(\"I don't like fruit\")\n",
    "        \n",
    "myfunc(fruit='pineapple')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I don't like fruit\n"
     ]
    }
   ],
   "source": [
    "myfunc()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `*args` and `**kwargs` combined\n",
    "\n",
    "You can pass `*args` and `**kwargs` into the same function, but `*args` have to appear before `**kwargs`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('eggs', 'spam')\n",
      "{'fruit': 'cherries', 'juice': 'orange'}\n",
      "I like eggs and spam and my favorite fruit is cherries\n",
      "May I have some orange juice?\n"
     ]
    }
   ],
   "source": [
    "def myfunc(*args, **kwargs):\n",
    "    print(args)\n",
    "    print(kwargs)\n",
    "    if 'fruit' and 'juice' in kwargs:\n",
    "        print(f\"I like {' and '.join(args)} and my favorite fruit is {kwargs['fruit']}\")\n",
    "        print(f\"May I have some {kwargs['juice']} juice?\")\n",
    "    else:\n",
    "        pass\n",
    "        \n",
    "myfunc('eggs','spam',fruit='cherries',juice='orange')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Placing keyworded arguments ahead of positional arguments raises an exception:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "positional argument follows keyword argument (<ipython-input-20-fc6ff65addcc>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-20-fc6ff65addcc>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    myfunc(fruit='cherries',juice='orange','eggs','spam')\u001b[0m\n\u001b[1;37m                                          ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m positional argument follows keyword argument\n"
     ]
    }
   ],
   "source": [
    "myfunc(fruit='cherries',juice='orange','eggs','spam')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with \"args\", you can use any name you'd like for keyworded arguments - \"kwargs\" is just a popular convention.\n",
    "\n",
    "That's it! Now you should understand how `*args` and `**kwargs` provide the flexibilty to work with arbitrary numbers of arguments!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "---\n",
    "---\n",
    "---\n",
    "# Scope with LEGB Rule, global, nonlocal keyword"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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. Variable <b>assignments</b> will create or change local names by default and result in error if not defined .\n",
    "2. Variable <b> references </b> are `searched` in four scopes(during accessing vars; not the assignment), these are:\n",
    "    * local\n",
    "    * enclosing functions\n",
    "    * global\n",
    "    * built-in\n",
    "3. Names declared in `global` and `nonlocal` statements map assigned names to function scopes and enclosing module respectively.\n",
    "\n",
    "- There is no local scope in python i.e it has a global scope , function/class scope, enclosing function/class scope .\n",
    "\n",
    "```python\n",
    "\n",
    "    \n",
    "n = 5\n",
    "for i in range(2):\n",
    "    n = 13\n",
    "    for j in range(3):\n",
    "        m = 5\n",
    "        for k in range(4):\n",
    "            a=1\n",
    "            for l in range(5):\n",
    "                b = 5\n",
    "                for x in range(6):\n",
    "                    a=3\n",
    "```\n",
    "- every var in code is in global scope.\n",
    "\n",
    "- The statement #2 above can be refered by the LEGB rule.\n",
    "\n",
    "**LEGB Rule:**\n",
    "\n",
    "    L: Local(functional) — Names assigned in any way within a function (def or lambda), and not declared global in that function.\n",
    "\n",
    "    E: Enclosing function locals — Names in the local scope of any and all enclosing functions (def or lambda), 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",
    "\n",
    "\n",
    "    B: Built-in (Python) — Names preassigned in the built-in names module : open, range, SyntaxError,..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## The <code>global</code> keyword\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` Keyword. \n",
    "\n",
    "**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 <code>global</code> statement makes it amply clear that the variable is defined in an outermost block.\n",
    "\n",
    "## The <code>nonlocal</code> keyword\n",
    "\n",
    "- To show that variable is already define in enclosing block not in global block we use `nonlocal` \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "out 50\n"
     ]
    }
   ],
   "source": [
    "x = 50\n",
    "\n",
    "def func():\n",
    "    x = 2\n",
    "    print(x)\n",
    "func()\n",
    "print(\"out\", x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "out 2\n"
     ]
    }
   ],
   "source": [
    "x = 50\n",
    "\n",
    "def func():\n",
    "    global x\n",
    "    x = 2\n",
    "    print(x)\n",
    "func()\n",
    "print(\"out\", x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "ename": "UnboundLocalError",
     "evalue": "local variable 'x' 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-23-9292cf88b28c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     11\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     12\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 13\u001b[1;33m \u001b[0mouter\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[0;32m     14\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     15\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<ipython-input-23-9292cf88b28c>\u001b[0m in \u001b[0;36mouter\u001b[1;34m()\u001b[0m\n\u001b[0;32m      7\u001b[0m         \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# use nonlocal to use enclosing x\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[0minner\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[0;32m     10\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     11\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<ipython-input-23-9292cf88b28c>\u001b[0m in \u001b[0;36minner\u001b[1;34m()\u001b[0m\n\u001b[0;32m      4\u001b[0m     \u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m\u001b[1;36m23\u001b[0m \u001b[1;31m# enclosing x\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0minner\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[0mx\u001b[0m\u001b[1;33m+=\u001b[0m\u001b[1;36m34\u001b[0m \u001b[1;31m# here it can not be assigned before x declaration\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[0mx\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# use nonlocal to use enclosing x\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 'x' referenced before assignment"
     ]
    }
   ],
   "source": [
    "x=344 # global x\n",
    "\n",
    "def outer():\n",
    "    x =23 # enclosing x\n",
    "    def inner():\n",
    "        x+=34 # here it can not be assigned before x declaration\n",
    "        print(x) # use nonlocal to use enclosing x\n",
    "        \n",
    "    inner()\n",
    "    print(x)\n",
    "    \n",
    "    \n",
    "outer()\n",
    "        \n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "57\n",
      "57\n"
     ]
    }
   ],
   "source": [
    "x=344 # global x\n",
    "\n",
    "def outer():\n",
    "    x =23 # enclosing x\n",
    "    def inner():\n",
    "        nonlocal x\n",
    "        x+=34 # here it can not be assigned before x declaration\n",
    "        print(x) # use nonlocal to use enclosing x\n",
    "        \n",
    "    inner()\n",
    "    print(x)\n",
    "    \n",
    "    \n",
    "outer()\n",
    "        \n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "378\n",
      "23\n"
     ]
    }
   ],
   "source": [
    "x=344 # global x\n",
    "\n",
    "def outer():\n",
    "    x =23 # enclosing x\n",
    "    def inner():\n",
    "        global x\n",
    "        x+=34 # here it can not be assigned before x declaration\n",
    "        print(x) # use nonlocal to use enclosing x\n",
    "        \n",
    "    inner()\n",
    "    print(x)\n",
    "    \n",
    "    \n",
    "outer()\n",
    "        \n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Note "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- when u assign a value to a variable inside function then it become local to that function  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=2\n",
    "def just_try():\n",
    "    print(x) # following LEGB Rule"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "just_try()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=3\n",
    "def just_try2():\n",
    "    x+=2 # x = x+2 ; here x becomes local now and on rhs i am accesing variable which is not declared locally hence error\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "ename": "UnboundLocalError",
     "evalue": "local variable 'x' 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-19-e99a5dc89757>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mjust_try2\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-18-cf7265643e23>\u001b[0m in \u001b[0;36mjust_try2\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mjust_try2\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----> 3\u001b[1;33m     \u001b[0mx\u001b[0m\u001b[1;33m+=\u001b[0m\u001b[1;36m2\u001b[0m \u001b[1;31m# x = x+2 ; here x becomes local now and on rhs i am accesing variable which is not declared locally hence error\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      4\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mUnboundLocalError\u001b[0m: local variable 'x' referenced before assignment"
     ]
    }
   ],
   "source": [
    "just_try2()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=34\n",
    "def just_try3():\n",
    "    x = 3  # here also x is declared locaaly hence no access to global\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "just_try3()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=23\n",
    "def just_try4():\n",
    "    global x \n",
    "    x=32\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23\n"
     ]
    }
   ],
   "source": [
    "just_try4()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What are the rules for local and global variables in Python?\n",
    "- In Python, variables that are only <em> referenced</em> inside a function are implicitly global. If a variable is assigned a value anywhere within the function’s body, it’s assumed to be a functional variable unless explicitly declared as global."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}