{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# More Advanced Python\n",
    "\n",
    "There are several advanced Python notions that you need to be familiar with. \n",
    "\n",
    "## Decorators\n",
    "\n",
    "\n",
    "### What is a Decorator?\n",
    "\n",
    "A **decorator** is a function that takes another function as input, adds some functionality to it, and returns it. You can apply decorators using the `@decorator_name` syntax.\n",
    "\n",
    "\n",
    "\n",
    "### Basic Example of a Decorator\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Something is happening before the function is called.\n",
      "Hello!\n",
      "Something is happening after the function is called.\n"
     ]
    }
   ],
   "source": [
    "# Define a simple decorator\n",
    "def my_decorator(func):\n",
    "    def wrapper():\n",
    "        print(\"Something is happening before the function is called.\")\n",
    "        func()\n",
    "        print(\"Something is happening after the function is called.\")\n",
    "    return wrapper\n",
    "\n",
    "# Define a function and decorate it\n",
    "@my_decorator\n",
    "def say_hello():\n",
    "    print(\"Hello!\")\n",
    "\n",
    "# Call the decorated function\n",
    "say_hello()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`@my_decorator` is syntactic sugar for:\n",
    "  ```python\n",
    "  say_hello = my_decorator(say_hello)\n",
    "  ```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Decorator with Arguments\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Boris!\n",
      "Hello, Boris!\n",
      "Hello, Boris!\n"
     ]
    }
   ],
   "source": [
    "def repeat_decorator(times):\n",
    "    def decorator(func):\n",
    "        def wrapper(*args, **kwargs):\n",
    "            for _ in range(times):\n",
    "                func(*args, **kwargs)\n",
    "        return wrapper\n",
    "    return decorator\n",
    "\n",
    "@repeat_decorator(times=3)\n",
    "def greet(name):\n",
    "    print(f\"Hello, {name}!\")\n",
    "\n",
    "greet(\"Boris\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here:\n",
    "\n",
    "- The `repeat_decorator` takes an argument (`times`) and returns the actual decorator.\n",
    "\n",
    "- The decorator wraps the `greet` function to execute it multiple times.\n",
    "\n",
    "\n",
    "### Using `functools.wraps` to Preserve Metadata\n",
    "\n",
    "When you wrap a function using a decorator, the original function's metadata (like its name and docstring) can be lost. \n",
    "\n",
    "Use `functools.wraps` to preserve it.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling decorated function...\n",
      "Example function is running!\n",
      "example_function\n",
      "This is an example function.\n"
     ]
    }
   ],
   "source": [
    "import functools\n",
    "\n",
    "def my_decorator(func):\n",
    "    @functools.wraps(func)\n",
    "    def wrapper(*args, **kwargs):\n",
    "        \"\"\"Wrapper function.\"\"\"\n",
    "        print(\"Calling decorated function...\")\n",
    "        return func(*args, **kwargs)\n",
    "    return wrapper\n",
    "\n",
    "@my_decorator\n",
    "def example_function():\n",
    "    \"\"\"This is an example function.\"\"\"\n",
    "    print(\"Example function is running!\")\n",
    "\n",
    "example_function()\n",
    "print(example_function.__name__)  # Output: example_function\n",
    "print(example_function.__doc__)  # Output: This is an example function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, we see that the metadata of the decorated function is preserved, namely the name (`__name__`) and the docstring (`__doc__`)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class-Based Decorators\n",
    "\n",
    "Decorators can also be implemented as classes.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before the function call.\n",
      "Hello!\n",
      "After the function call.\n"
     ]
    }
   ],
   "source": [
    "class MyDecorator:\n",
    "    def __init__(self, func):\n",
    "        self.func = func\n",
    "\n",
    "    def __call__(self, *args, **kwargs):\n",
    "        print(\"Before the function call.\")\n",
    "        result = self.func(*args, **kwargs)\n",
    "        print(\"After the function call.\")\n",
    "        return result\n",
    "    \n",
    "@MyDecorator\n",
    "def say_hello():\n",
    "    print(\"Hello!\")\n",
    "\n",
    "say_hello()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "Here, the `__call__` method makes the class instance callable, so it acts like a decorator. In this case, you don't need to define a wrapper function inside the decorator.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Chaining Multiple Decorators\n",
    "\n",
    "You can apply multiple decorators to a function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HELLO, BORIS!\n"
     ]
    }
   ],
   "source": [
    "def uppercase(func):\n",
    "    def wrapper(*args, **kwargs):\n",
    "        result = func(*args, **kwargs)\n",
    "        return result.upper()\n",
    "    return wrapper\n",
    "\n",
    "def exclaim(func):\n",
    "    def wrapper(*args, **kwargs):\n",
    "        result = func(*args, **kwargs)\n",
    "        return result + \"!\"\n",
    "    return wrapper\n",
    "\n",
    "@exclaim\n",
    "@uppercase\n",
    "def greet(name):\n",
    "    return f\"hello, {name}\"\n",
    "\n",
    "print(greet(\"Boris\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `@uppercase` is applied first, transforming the string to uppercase.\n",
    "- `@exclaim` is applied next, adding an exclamation mark."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Real-World Example: \n",
    "\n",
    "#### Timing a Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finished!\n",
      "Execution time: 2.0050 seconds\n",
      "Finished!\n",
      "Execution time: 0.1015 seconds\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "def timing_decorator(func):\n",
    "    def wrapper(*args, **kwargs):\n",
    "        start_time = time.time()\n",
    "        result = func(*args, **kwargs)\n",
    "        end_time = time.time()\n",
    "        print(f\"Execution time: {end_time - start_time:.4f} seconds\")\n",
    "        return result\n",
    "    return wrapper\n",
    "\n",
    "@timing_decorator\n",
    "def slow_function():\n",
    "    time.sleep(2)\n",
    "    print(\"Finished!\")\n",
    "\n",
    "\n",
    "\n",
    "@timing_decorator\n",
    "def fast_function():\n",
    "    time.sleep(0.1)\n",
    "    print(\"Finished!\")\n",
    "\n",
    "slow_function()\n",
    "fast_function()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example we don't need to re-implement the timing logic, thanks to the decorator.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Vectorizing a Function\n",
    "\n",
    "\n",
    "If you have a regular function and want to apply `np.vectorize`, you can explicitly wrap the function with `np.vectorize`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 0 0 1 4]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Define a regular function\n",
    "def my_function(x):\n",
    "    return x ** 2 if x > 0 else 0\n",
    "\n",
    "# Vectorize it\n",
    "vectorized_function = np.vectorize(my_function)\n",
    "\n",
    "# Apply it to a NumPy array\n",
    "data = np.array([-2, -1, 0, 1, 2])\n",
    "result = vectorized_function(data)\n",
    "print(result)  # Output: [0 0 0 1 4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# my_function(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Using `np.vectorize` as a decorator simplifies the process and automatically transforms the function for vectorized operations.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 0 0 1 4]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Use np.vectorize as a decorator\n",
    "@np.vectorize\n",
    "def my_function(x):\n",
    "    return x ** 2 if x > 0 else 0\n",
    "\n",
    "# Apply it to a NumPy array\n",
    "data = np.array([-2, -1, 0, 1, 2])\n",
    "result = my_function(data)\n",
    "print(result)  # Output: [0 0 0 1 4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, the `@np.vectorize` decorator is applied directly to `my_function`, so you don't need to explicitly wrap it later.\n",
    "\n",
    "\n",
    "To recap:\n",
    "\n",
    "1. **Without Decorator**:\n",
    "\n",
    "   - You have to manually apply `np.vectorize` to the function.\n",
    "\n",
    "   - More verbose.\n",
    "\n",
    "2. **With Decorator**:\n",
    "\n",
    "   - Cleaner and more readable.\n",
    "\n",
    "   - Automatically makes the function vectorized when defined.\n",
    "\n",
    "\n",
    "\n",
    "`np.vectorize` is useful for extending scalar functions to arrays when you don't want to manually iterate over elements. \n",
    "\n",
    "However, it doesn't provide true performance benefits like NumPy's `ufuncs` (universal functions), as it’s just a convenience for element-wise operations. If possible, prefer writing functions that natively work with arrays for better performance.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.41421356, 1.        , 0.        , 1.        , 1.41421356])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt(np.abs(data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.41421356, 1.        , 0.        , 1.        , 1.41421356])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.abs(data)**0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy Universal Functions (ufuncs)\n",
    "\n",
    "A universal function (or ufunc for short) is a function that operates on ndarrays in an element-by-element fashion, supporting array broadcasting, type casting, and several other standard features. That is, a ufunc is a “vectorized” wrapper for a function that takes a fixed number of specific inputs and produces a fixed number of specific outputs (see [here](https://numpy.org/doc/2.1/user/basics.ufuncs.html#ufuncs-basics)).\n",
    "\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 7 9]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Element-wise addition\n",
    "arr1 = np.array([1, 2, 3])\n",
    "arr2 = np.array([4, 5, 6])\n",
    "\n",
    "result = arr1 + arr2  # Uses ufunc np.add\n",
    "print(result)  # Output: [5 7 9]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Square-root, and trigonometric functions in numpy are also ufuncs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 2. 3. 4.]\n",
      "[0.0000000e+00 1.0000000e+00 1.2246468e-16]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1, 4, 9, 16])\n",
    "\n",
    "# Square root\n",
    "sqrt_result = np.sqrt(arr)\n",
    "print(sqrt_result)  # Output: [1. 2. 3. 4.]\n",
    "\n",
    "# Trigonometric functions\n",
    "angles = np.array([0, np.pi / 2, np.pi])\n",
    "sin_result = np.sin(angles)\n",
    "print(sin_result)  # Output: [0. 1. 0.]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can create a custom ufunc from a Python function as well. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 7 9]\n"
     ]
    }
   ],
   "source": [
    "def custom_add(x, y):\n",
    "    return x + y\n",
    "\n",
    "# Create ufunc\n",
    "custom_add_ufunc = np.frompyfunc(custom_add, 2, 1)\n",
    "\n",
    "result = custom_add_ufunc([1, 2, 3], [4, 5, 6])\n",
    "print(result)  # Output: [5 7 9]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is an example of the huge performance benefits of ufuncs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ufunc time: 0.007639 seconds\n",
      "np.vectorize time: 0.117718 seconds\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import time\n",
    "\n",
    "# Data\n",
    "arr = np.arange(1e6)\n",
    "\n",
    "# Using ufunc\n",
    "start = time.time()\n",
    "result_ufunc = np.sqrt(arr)\n",
    "end = time.time()\n",
    "print(f\"ufunc time: {end - start:.6f} seconds\")\n",
    "\n",
    "# Using np.vectorize\n",
    "def scalar_sqrt(x):\n",
    "    return x ** 0.5\n",
    "\n",
    "vectorized_sqrt = np.vectorize(scalar_sqrt)\n",
    "start = time.time()\n",
    "result_vectorized = vectorized_sqrt(arr)\n",
    "end = time.time()\n",
    "print(f\"np.vectorize time: {end - start:.6f} seconds\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the ufunc version is 100 times faster than the vectorized version. The vectorized version actually iterates over the elements of the array, while the ufunc version is implemented in C under the hood and is highly optimized."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logging\n",
    "\n",
    "Logging is used to track events in a program and helps debug or monitor it without relying on print statements. \n",
    "\n",
    "It’s better because it categorizes messages by **severity levels** (e.g., `INFO`, `WARNING`, `ERROR`) and can output logs to different destinations (e.g., files).\n",
    "\n",
    "\n",
    "### Basic Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO: Computed square of 5: 25\n",
      "WARNING: Received a negative number. Returning zero.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import logging\n",
    "\n",
    "# Configure basic logging\n",
    "logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')\n",
    "\n",
    "# Example: A simple computation\n",
    "def compute_square(x):\n",
    "    if x < 0:\n",
    "        logging.warning(\"Received a negative number. Returning zero.\")\n",
    "        return 0\n",
    "    result = x ** 2\n",
    "    logging.info(f\"Computed square of {x}: {result}\")\n",
    "    return result\n",
    "\n",
    "# Call the function\n",
    "compute_square(5)\n",
    "compute_square(-3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "1. Log Levels Used:\n",
    "\n",
    "   - `INFO`: Logs useful computation results.\n",
    "\n",
    "   - `WARNING`: Logs when unexpected input is received.\n",
    "\n",
    "2. Why Use Logging?\n",
    "\n",
    "   - It separates debugging messages from your main program output.\n",
    "\n",
    "   - It's easy to expand (e.g., write to files, add timestamps).\n",
    "\n",
    "\n",
    "### Activating and Deactivating Logging\n",
    "\n",
    "Sometimes, you may want to turn logging **on** or **off** depending on the situation (e.g., during debugging or production).\n",
    "\n",
    "\n",
    "\n",
    "**How to Deactivate Logging?**\n",
    "\n",
    "To deactivate logging, set the logging level to `logging.CRITICAL`. Since this is the highest level, only critical errors will be logged, effectively \"silencing\" other logs.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO: Computed square of 5: 25\n",
      "WARNING: Received a negative number. Returning zero.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import logging\n",
    "\n",
    "# Configure basic logging\n",
    "logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')\n",
    "\n",
    "# Example function with logging\n",
    "def compute_square(x):\n",
    "    if x < 0:\n",
    "        logging.warning(\"Received a negative number. Returning zero.\")\n",
    "        return 0\n",
    "    result = x ** 2\n",
    "    logging.info(f\"Computed square of {x}: {result}\")\n",
    "    return result\n",
    "\n",
    "# Activate logging (default level INFO)\n",
    "compute_square(5)  # Logs: INFO: Computed square of 5: 25\n",
    "compute_square(-3)  # Logs: WARNING: Received a negative number. Returning zero.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Deactivate logging\n",
    "logging.getLogger().setLevel(logging.CRITICAL)\n",
    "\n",
    "compute_square(5)  # No logs\n",
    "compute_square(-3)  # No logs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**How to Reactivate Logging?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO: Computed square of 5: 25\n",
      "WARNING: Received a negative number. Returning zero.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "logging.getLogger().setLevel(logging.INFO)\n",
    "\n",
    "compute_square(5)  # Logs: INFO: Computed square of 5: 25\n",
    "compute_square(-3)  # Logs: WARNING: Received a negative number. Returning zero."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This allows you to easily toggle logging without removing or modifying your logging statements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Global and Local Variables\n",
    "\n",
    "Variables in python can have global or local scope. \n",
    "\n",
    "**Global variables** are accessible everywhere.\n",
    "\n",
    "**Local variables** are only accessible in the function they are defined in.\n",
    "\n",
    "Variables created in `for`, `while` and `if` statements are **global**, so available outside the loop (as are the iterators, e.g. `i` in `for i in range(10)`). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "2\n",
      "101\n",
      "102\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    j=100\n",
    "print(j)\n",
    "print(i)\n",
    "i=0\n",
    "\n",
    "while i<2:\n",
    "    j=101\n",
    "    i=5\n",
    "print(j) \n",
    "\n",
    "if (True):\n",
    "    j=102\n",
    "print(j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"exercise-box\">\n",
    "**Exercise:** Explain the output of the code above.\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variables created in functions are **local**, so not available outside the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "102\n"
     ]
    }
   ],
   "source": [
    "def f():\n",
    "    j=103\n",
    "f()\n",
    "print(j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"exercise-box\">\n",
    "**Exercise:** Explain the output of the code above.\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When global and local variables have the same name python creates two instances.\n",
    "\n",
    "The local variable takes precedence in the function and dies at the end of it, the global variable takes precedence outside the function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "104\n"
     ]
    },
    {
     "ename": "UnboundLocalError",
     "evalue": "local variable 'k' referenced before assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mUnboundLocalError\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn [33], line 12\u001b[0m\n\u001b[1;32m     10\u001b[0m     k\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m105\u001b[39m\n\u001b[1;32m     11\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;241m0\u001b[39m\n\u001b[0;32m---> 12\u001b[0m \u001b[43mfunction3\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     13\u001b[0m \u001b[38;5;66;03m# print(k)\u001b[39;00m\n",
      "Cell \u001b[0;32mIn [33], line 10\u001b[0m, in \u001b[0;36mfunction3\u001b[0;34m()\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mfunction3\u001b[39m():\n\u001b[0;32m---> 10\u001b[0m     k\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m105\u001b[39m\n\u001b[1;32m     11\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;241m0\u001b[39m\n",
      "\u001b[0;31mUnboundLocalError\u001b[0m: local variable 'k' referenced before assignment"
     ]
    }
   ],
   "source": [
    "\n",
    "k=104\n",
    "def function2(): \n",
    "    k=105\n",
    "    return 0\n",
    "function2()\n",
    "print(k)\n",
    "\n",
    "k=104\n",
    "def function3():\n",
    "    k+=105\n",
    "    return 0\n",
    "function3()\n",
    "# print(k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"exercise-box\">\n",
    "**Exercise:** Explain the output of the code above.\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Deep and Shallow Copies\n",
    "\n",
    "Here is an example of a shallow copy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original: [[99, 2, 3], [4, 5, 6]]\n",
      "Shallow: [[99, 2, 3], [4, 5, 6]]\n",
      "Original: [[87, 2, 3], [4, 5, 6]]\n",
      "Shallow: [[87, 2, 3], [4, 5, 6]]\n"
     ]
    }
   ],
   "source": [
    "# Original list\n",
    "original = [[1, 2, 3], [4, 5, 6]]\n",
    "\n",
    "# Shallow copy \n",
    "shallow = original\n",
    "\n",
    "# Modify the nested object\n",
    "shallow[0][0] = 99\n",
    "\n",
    "print(\"Original:\", original)  # Output: [[99, 2, 3], [4, 5, 6]]\n",
    "print(\"Shallow:\", shallow)    # Output: [[99, 2, 3], [4, 5, 6]]\n",
    "\n",
    "\n",
    "original[0][0] = 87\n",
    "\n",
    "print(\"Original:\", original)  # Output: [[87, 2, 3], [4, 5, 6]]\n",
    "print(\"Shallow:\", shallow)    # Output: [[87, 2, 3], [4, 5, 6]]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"exercise-box\">\n",
    "**Exercise:** Explain the output of the code above.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is an example of a deep copy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original: [[1, 2, 3], [4, 5, 6]]\n",
      "Deep: [[99, 2, 3], [4, 5, 6]]\n",
      "Original: [[87, 2, 3], [4, 5, 6]]\n",
      "Deep: [[99, 2, 3], [4, 5, 6]]\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "# Original list\n",
    "original = [[1, 2, 3], [4, 5, 6]]\n",
    "\n",
    "# Deep copy \n",
    "deep = copy.deepcopy(original)\n",
    "\n",
    "# Modify the nested object\n",
    "deep[0][0] = 99\n",
    "\n",
    "print(\"Original:\", original)  # Output: [[1, 2, 3], [4, 5, 6]]\n",
    "print(\"Deep:\", deep)    # Output: [[99, 2, 3], [4, 5, 6]]\n",
    "\n",
    "\n",
    "original[0][0] = 87\n",
    "\n",
    "print(\"Original:\", original)  # Output: [[87, 2, 3], [4, 5, 6]]\n",
    "print(\"Deep:\", deep)    # Output: [[99, 2, 3], [4, 5, 6]]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"exercise-box\">\n",
    "**Exercise:** Explain the output of the code above.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also create a deep copy using list comprehension:\n",
    "\n",
    "```python\n",
    "deep = [inner[:] for inner in original]\n",
    "```\n",
    "\n",
    "The same applies to dictionaries."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"exercise-box\">\n",
    "**Exercise:** Write the examples above for dictionaries.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists and tuples\n",
    "\n",
    "\n",
    "Lists and tuples are two fundamental data structures in Python, with lists being mutable ordered collections and tuples being immutable ordered collections.\n",
    "\n",
    "\n",
    "### Lists\n",
    "\n",
    "- **Mutable**: You can change, add, or remove elements.\n",
    "\n",
    "- **Defined with square brackets (`[]`)**.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "[10, 2, 3]\n",
      "[10, 2, 3, 4]\n",
      "[10, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# Create a list\n",
    "my_list = [1, 2, 3]\n",
    "\n",
    "# Access elements\n",
    "print(my_list[0])  # Output: 1\n",
    "\n",
    "# Modify elements\n",
    "my_list[0] = 10\n",
    "print(my_list)  # Output: [10, 2, 3]\n",
    "\n",
    "# Add elements\n",
    "my_list.append(4)\n",
    "print(my_list)  # Output: [10, 2, 3, 4]\n",
    "\n",
    "# Remove elements\n",
    "my_list.pop()\n",
    "print(my_list)  # Output: [10, 2, 3]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Tuples\n",
    "\n",
    "- **Immutable**: Cannot change elements after creation.\n",
    "\n",
    "- **Defined with parentheses (`()`)**.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "# Create a tuple\n",
    "my_tuple = (1, 2, 3)\n",
    "\n",
    "# Access elements\n",
    "print(my_tuple[0])  # Output: 1\n",
    "\n",
    "# Cannot modify elements\n",
    "# my_tuple[0] = 10  # Error: 'tuple' object does not support item assignment\n",
    "\n",
    "# Tuples support slicing\n",
    "print(my_tuple[1:])  # Output: (2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "### Key Differences\n",
    "\n",
    "| Feature            | List              | Tuple             |\n",
    "|--------------------|-------------------|-------------------|\n",
    "| **Mutability**     | Mutable           | Immutable         |\n",
    "| **Syntax**         | `[1, 2, 3]`       | `(1, 2, 3)`       |\n",
    "| **Performance**    | Slower            | Faster            |\n",
    "| **Use Case**       | Dynamic data      | Fixed data        |\n",
    "\n",
    "\n",
    "### Quick Tip\n",
    "\n",
    "- Use **lists** when data changes frequently.\n",
    "\n",
    "- Use **tuples** when data is constant (e.g., coordinates, configuration settings)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class polymorphism\n",
    "\n",
    "\n",
    "Here is an explicit example of polymorphism in Python.\n",
    "\n",
    "\n",
    "\n",
    "### Define a Base Class\n",
    "\n",
    "A base class provides a common interface with a method that can be overridden by subclasses.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class Shape:\n",
    "    def area(self):\n",
    "        raise NotImplementedError(\"Subclasses must override this method\")\n",
    "    \n",
    "    def perimeter(self):\n",
    "        raise NotImplementedError(\"Subclasses must override this method\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "### Create Subclasses   \n",
    "\n",
    "Each subclass implements the `area` and `perimeter` methods differently, depending on the specific shape.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class Rectangle(Shape):\n",
    "    def __init__(self, width, height):\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "\n",
    "    def area(self):\n",
    "        return self.width * self.height\n",
    "\n",
    "    def perimeter(self):\n",
    "        return 2 * (self.width + self.height)\n",
    "\n",
    "class Circle(Shape):\n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "\n",
    "    def area(self):\n",
    "        return 3.14159 * self.radius ** 2\n",
    "\n",
    "    def perimeter(self):\n",
    "        return 2 * 3.14159 * self.radius\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Use Polymorphism\n",
    "\n",
    "You can use objects of `Rectangle` and `Circle` interchangeably when working with the `Shape` interface.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area: 12\n",
      "Perimeter: 14\n",
      "Area: 78.53975\n",
      "Perimeter: 31.4159\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# List of shapes\n",
    "shapes = [Rectangle(3, 4), Circle(5)]\n",
    "\n",
    "# Polymorphic behavior\n",
    "for shape in shapes:\n",
    "    print(f\"Area: {shape.area()}\")\n",
    "    print(f\"Perimeter: {shape.perimeter()}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "### Explanation\n",
    "\n",
    "1. Both `Rectangle` and `Circle` override the `area` and `perimeter` methods from the `Shape` base class.\n",
    "\n",
    "2. The loop processes each shape **polymorphically**, calling the appropriate method implementation depending on the object type.\n",
    "\n",
    "3. This makes the code flexible and extensible for new shapes without modifying existing logic."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Just-in-time compilation\n",
    "\n",
    "Just-In-Time (JIT) compilation is a technique to improve the performance of Python code by compiling parts of the code to machine code at runtime. (Python code is not normally converted to machine code at runtime. Instead, it is interpreted or compiled into **bytecode** stored in `.pyc` files, which is then executed by the Python interpreter.)\n",
    "\n",
    "\n",
    "This can make code run significantly faster. A common tool for JIT in Python is Numba.\n",
    "\n",
    "\n",
    "\n",
    "Let us see an example. \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import necessary modules\n",
    "from numba import jit\n",
    "import timeit\n",
    "\n",
    "# Define functions\n",
    "def sum_of_squares(n):\n",
    "    total = 0\n",
    "    for i in range(n):\n",
    "        total += i * i\n",
    "    return total\n",
    "\n",
    "@jit\n",
    "def sum_of_squares_jit(n):\n",
    "    total = 0\n",
    "    for i in range(n):\n",
    "        total += i * i\n",
    "    return total\n",
    "\n",
    "# Input size\n",
    "n = 10**6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "41.6 ms ± 597 µs per loop (mean ± std. dev. of 3 runs, 10 loops each)\n",
      "147 ns ± 60.9 ns per loop (mean ± std. dev. of 3 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "# Time the functions\n",
    "# Without JIT\n",
    "%timeit -n 10 -r 3 sum_of_squares(n)\n",
    "\n",
    "# With JIT\n",
    "# ensures the function is compiled before timing, so only runtime performance is measured\n",
    "sum_of_squares_jit(n)\n",
    "\n",
    "# Time JIT version\n",
    "%timeit -n 10 -r 3 sum_of_squares_jit(n)\n",
    "\n"
   ]
  }
 ],
 "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.9"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}