018_Functions_Part3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "853ef2c1-076c-4052-903e-8a3fc081fd16",
   "metadata": {},
   "source": [
    "#### Scope and Lifetime of Variables in Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b11cf2e2-1275-437b-ae78-d803fe8dfc83",
   "metadata": {},
   "source": [
    "- `Scope` and `lifetime` of variables is essential for writing efficient, error-free programs.\n",
    "- `Scope` defines where a variable can be accessed.\n",
    "- `Lifetime` refers to how long it stays in memory before being cleared."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "bef915ca-d0b1-4eba-a3b0-91df2e71bff6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Scope in Python simply defines where in the code a variable can be accessed or modified.\n",
    "# Imagine you are in a home where you have access to every items\n",
    "# But if you leave the home, you can’t access any items"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5291169-6d24-4922-bde8-2a936ceaf057",
   "metadata": {},
   "source": [
    "In Python, a variable’s scope depends on where it was created. For example, if you declare a variable inside a function, it’s only available inside that function. If you try to use it outside, Python will throw an error because that variable doesn’t exist beyond the function’s “body”"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "052301aa-df20-46ae-8c8f-671d37285180",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Variable Lifetime\n",
    "# lifetime of a variable, which is essentially how long the variable exists in memory."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e3bf30f-aa3d-4c53-8e98-3e7d2c0b4af9",
   "metadata": {},
   "source": [
    "In Python, a variable’s lifetime begins when it is created and ends when it goes out of scope (i.e., when the function ends or the program reaches the end of its block). Variables created inside a function, for example, disappear once the function finishes executing. They’re temporary—there one moment and gone the next."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "928b744a-60c1-45a7-a032-89820972398e",
   "metadata": {},
   "source": [
    "#### Types of Scope in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cc51deb-8b5a-4bd4-a65e-54aaa872180d",
   "metadata": {},
   "source": [
    "Python uses four main types of scope: \n",
    "\n",
    "- local,\n",
    "- global,\n",
    "- enclosing (or nonlocal),\n",
    "- built-in.\n",
    "\n",
    "Each type defines how variables behave in different parts of your program, from inside a function to across multiple modules."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee60706f-b8af-4f4b-9802-99cc4b1496c6",
   "metadata": {},
   "source": [
    "#### Local Scope in Python Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e8eb873-870b-4c2d-89c9-5d7080246936",
   "metadata": {},
   "source": [
    "- In Python, local scope refers to variables that are created and used within a function. These variables exist only while the function is executing and are not accessible from outside that function.\n",
    "- When a variable is defined inside a function, Python treats it as local to that function. This means the variable only exists within the function’s scope. Once the function has finished running, the variable is essentially forgotten and disappears from memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f68b898f-3c91-4976-85d6-881740dc7826",
   "metadata": {},
   "outputs": [],
   "source": [
    "def addition():\n",
    "    num1 = 10\n",
    "    num2 = 20\n",
    "    total = num1 + num2\n",
    "    print(total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0a3cbc81-95ac-4d42-bd4d-98aad9b2f00c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "addition()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "7d82e630-c201-4953-a770-91f39e6314c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# call num1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36a1272e-5f70-447c-a714-7054cf97efcb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# call num2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aeb4a687-d704-4444-88a5-e00280c7e93a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# call total"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c98b029-91d3-485a-a960-5d685d4c1d83",
   "metadata": {},
   "source": [
    "Conclusion: The Local scope is essential for keeping variables isolated and avoiding unexpected behavior in your program. By defining variables locally within functions, you ensure that their impact stays within the function itself, preventing conflicts with other variables outside that function."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6904926b-8d7c-42f9-93f9-3705ae22a375",
   "metadata": {},
   "source": [
    "#### Global Scope in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a9ce766-6734-46ac-b836-7b6c6373af49",
   "metadata": {},
   "source": [
    "In Python, global scope refers to variables that are accessible throughout the entire program, regardless of where they are declared. These variables are defined outside of any function or class, which means they can be accessed and modified anywhere in your code. Global variables have a longer lifetime compared to local ones, staying in memory as long as the program is running."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50e4f41e-fdde-4b15-9aa3-32bf041d7a4e",
   "metadata": {},
   "source": [
    "Note: inside the functions, we use the keyword `global` to let Python know we’re referring to the global counter variable, not creating a local one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6253e2d1-c697-4fda-8f9e-5bb7cfa1d257",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Without Global\n",
    "x = 10\n",
    "def modify_var():\n",
    "    x = 5\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "17bef845-7009-4b59-9775-2332365571f8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "modify_var()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "3d21e59f-03dd-4f2b-8dc2-9d63312761fa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "# With Global\n",
    "x = 10\n",
    "\n",
    "def modify_var():\n",
    "    global x\n",
    "    print(x)\n",
    "\n",
    "modify_var()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5b736ce-2a91-44e4-88bb-1038b2adb23b",
   "metadata": {},
   "source": [
    "Conclusion: \n",
    "\n",
    "`When to use global scope variables:`\n",
    "- When the variable’s value needs to be shared across multiple functions.\n",
    "- The variable holds a piece of data that remains relevant throughout the entire runtime of the program."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "559dfd52-9128-4ac5-a3d8-2712657ff123",
   "metadata": {},
   "source": [
    "#### Enclosing(Nonlocal) Scope in Nested Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "938889a4-c20e-4e27-a260-154214674e7e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am in the enclosing scope\n"
     ]
    }
   ],
   "source": [
    "def outer_function():\n",
    "    enclosing_var = \"I am in the enclosing scope\"\n",
    "\n",
    "    def inner_function():\n",
    "        print(enclosing_var)  # Output: I am in the enclosing scope\n",
    "\n",
    "    inner_function()\n",
    "\n",
    "outer_function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "ce8dd7a6-7df8-47ac-8b02-d203eb065aa4",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'enclosing_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[22], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[38;5;28mprint\u001b[39m(enclosing_var)\n",
      "\u001b[1;31mNameError\u001b[0m: name 'enclosing_var' is not defined"
     ]
    }
   ],
   "source": [
    "print(enclosing_var)  # This will raise a NameError because enclosing_var is no longer available"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de263d77-5573-4771-ba27-63f1285b3767",
   "metadata": {},
   "source": [
    "#### Built-in Scope in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89429cd5-366b-41d9-bb48-f1a683214b76",
   "metadata": {},
   "source": [
    "In Python, the built-in scope is like a special area in the language where built-in functions and constants live. These are always available to you, no matter where you are in your code. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "838dc2d4-676d-49dc-a2f1-74e4eb620e96",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a6f8d5a2-80b1-4860-81ca-d419c02fd31d",
   "metadata": {},
   "source": [
    "#### Understanding the LEGB Rule in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75e1053c-ae13-491b-9776-f577d1515875",
   "metadata": {},
   "source": [
    "The LEGB rule is a fundamental concept in Python programming that helps us understand how variables are resolved within different scopes. By following this rule, Python can determine which variable to use in various contexts. Here’s a detailed look at the LEGB rule and its importance in Python programming."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9aa55b0b-222b-40f1-b284-1b0d83ecbc2e",
   "metadata": {},
   "source": [
    "What is the `LEGB Rule`?\n",
    "\n",
    "\n",
    "The `LEGB rule` stands for `Local, Enclosing, Global, and Built-in`. It is a guideline for Python’s variable scope resolution. Essentially, Python searches for a variable name in a specific order:\n",
    "\n",
    "- `Local:` The innermost scope, where variables are defined within the current function or method.\n",
    "- `Enclosing:` The scope of any enclosing functions, such as in nested functions.\n",
    "- `Global:` The top-level scope of the module or script.\n",
    "- `Built-in:` The outermost scope, which includes Python’s built-in names like len() or print()."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54a22ea4-6ee6-4d1e-b6f8-8c8d0bc49d77",
   "metadata": {},
   "source": [
    "`Local Scope:` This is the most specific scope where variables are first looked up. Variables defined within a function or method are considered local to that function.\n",
    "\n",
    "`Enclosing Scope:` If the variable is not found in the local scope, Python looks in the enclosing scopes. This is relevant in nested functions where an inner function can access variables from its outer function.\n",
    "\n",
    "`Global Scope:` If the variable is not found in either the local or enclosing scopes, Python then searches the global scope. Variables defined at the top level of a module or script fall into this category.\n",
    "\n",
    "`Built-in Scope:` Finally, if the variable is not found in any of the above scopes, Python checks the built-in scope. This includes names that are built into Python, like len or range."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "cc613f15-6e66-468c-8d7a-a91487f8b619",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Global scope\n",
    "x = \"global x\"\n",
    "\n",
    "def outer_function():\n",
    "    # Enclosing scope\n",
    "    x = \"enclosing x\"\n",
    "    \n",
    "    def inner_function():\n",
    "        # Local scope\n",
    "        x = \"local x\"\n",
    "        print(\"Inner:\", x)  # This will print the local x\n",
    "\n",
    "    inner_function()\n",
    "    print(\"Outer:\", x)  # This will print the enclosing x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "14cfb778-01a8-4f2a-ab29-7738c9fc42cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inner: local x\n",
      "Outer: enclosing x\n"
     ]
    }
   ],
   "source": [
    "outer_function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "759b9f6a-cc08-40f7-bf33-f5b739be8b17",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Global: global x\n"
     ]
    }
   ],
   "source": [
    "print(\"Global:\", x)  # This will print the global x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10433a38-1235-4ce2-9f0b-8de1c9052642",
   "metadata": {},
   "source": [
    "#### Closures in Python Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6796764-25c6-491e-b840-dc0e346cfa84",
   "metadata": {},
   "source": [
    "Closures are a powerful feature in Python. They allow a function to remember the environment in which it was created. Here’s a simplified breakdown:\n",
    "\n",
    "When a function is defined inside another function, the inner function can remember and access the variables of the outer function even after the outer function has finished executing. This combination of a function and its lexical environment is called a closure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "79919113-f2c2-44bc-b95a-35ac5a01093e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def outer_function(text):\n",
    "    def inner_function():\n",
    "        print(text)\n",
    "    return inner_function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "339f5dc4-765d-4646-928f-2592b09beb7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_closure = outer_function(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "8f638b34-dbd6-4554-9151-47cd20380fce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.outer_function.<locals>.inner_function()>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_closure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "4e6787d5-714f-4e26-814e-6524d84218d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "my_closure()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "c2efc4ef-6dae-420f-9cb8-6a99a73cbc91",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "my_closure()"
   ]
  }
 ],
 "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.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}