16)WritingFunctions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Writing Functions in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 1: Best Practices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Doctstrings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def function_name(arguments):\n",
    "    \"\"\"\n",
    "    Description of what the function does\n",
    "\n",
    "    Description of the arguments, if any\n",
    "\n",
    "    Descriotion of the return value(s), if any\n",
    "\n",
    "    Description of error raised, if any\n",
    "\n",
    "    Optional extra notes or examples of usage\n",
    "    \"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "    Description of what the function does\n",
      "\n",
      "    Description of the arguments, if any\n",
      "\n",
      "    Descriotion of the return value(s), if any\n",
      "\n",
      "    Description of error raised, if any\n",
      "\n",
      "    Optional extra notes or examples of usage\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "#To obtain the doctsring of a function:\n",
    "\n",
    "print(function_name.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Description of what the function does\n",
      "\n",
      "Description of the arguments, if any\n",
      "\n",
      "Descriotion of the return value(s), if any\n",
      "\n",
      "Description of error raised, if any\n",
      "\n",
      "Optional extra notes or examples of usage\n"
     ]
    }
   ],
   "source": [
    "# To get a cleaner version we can also use\n",
    "\n",
    "import inspect \n",
    "print(inspect.getdoc(function_name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how the `count_letter.__doc__` version of the docstring had strange whitespace at the beginning of all but the first line. That's because the docstring is indented to line up visually when reading the code. But when we want to print the docstring, removing those leading spaces with `inspect.getdoc()` will look much better."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### DRY (Don't repeat yourself) and \"Do One Thing\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first idea is that you should avoid copying and pasting the same code for for example ploting train, valid and test data and only changing the name of the df. Instead we should write a function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_and_plot(path):\n",
    "    \"\"\"Load a dataset and plot the first two principal components\n",
    "\n",
    "    Args:\n",
    "        path (str): The location of a CSV file\n",
    "\n",
    "    Returns:\n",
    "        tuple of ndarray: (featurs, labels)\n",
    "    \"\"\"\n",
    "    data = pd.read_csv(path)\n",
    "    y = data[\"label\"].values\n",
    "    X = data[col for col in data.columns if col != \"label\"].values\n",
    "    pca = PCA(n_components=2).fit_transform(X)\n",
    "    plt.scatter(pca[:, 0], pca[:, 1])\n",
    "    return X, y\n",
    "\n",
    "train_X, train_y = load_and_plot(\"train.csv\")\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Do one thing** principal states that every function should only have one responsibility, while ours has 3 of them"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The solution if two create two functions instead of one"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Task 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def standardize(column):\n",
    "  \"\"\"Standardize the values in a column.\n",
    "\n",
    "  Args:\n",
    "    column (pandas Series): The data to standardize.\n",
    "\n",
    "  Returns:\n",
    "    pandas Series: the values as z-scores\n",
    "  \"\"\"\n",
    "  # Finish the function so that it returns the z-scores\n",
    "  z_score = (df[column] - df[column].mean()) / df[column].std()\n",
    "  return z_score\n",
    "\n",
    "# Use the standardize() function to calculate the z-scores\n",
    "df['y1_z'] = standardize(\"y1_gpa\")\n",
    "df['y2_z'] = standardize(\"y2_gpa\")\n",
    "df['y3_z'] = standardize(\"y3_gpa\")\n",
    "df['y4_z'] = standardize(\"y4_gpa\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pass by assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[99, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "def foo(x):\n",
    "    x[0] = 99\n",
    "\n",
    "my_list = [1, 2, 3]\n",
    "foo(my_list)\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists are mutable objects and therefore we were able to change them in a cell above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "def bar(x):\n",
    "    x = x + 90\n",
    "my_var = 3\n",
    "bar(my_var)\n",
    "print(my_var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And as for the integers - they are immutable (can't be changed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Immutable:\n",
    "- int\n",
    "- float\n",
    "- bool\n",
    "- string\n",
    "- bytes\n",
    "- tuple\n",
    "- frozenset\n",
    "- None\n",
    "\n",
    "All the others are mutable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 2: Contex Managers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using context manager"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An analogy to explain what does the context manager do?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table>\n",
    "    <thead>\n",
    "        <td><b>Context managers:</b></td>\n",
    "        <td><b>Caterers:</b></td>\n",
    "    </thead>\n",
    "    <tbody>\n",
    "        <tr>\n",
    "            <td>Set up a context</td>\n",
    "            <td>Set up the tables with food and drink</td>\n",
    "        <tr>\n",
    "        <tr>\n",
    "            <td>Run your code</td>\n",
    "            <td>Let you and your friends have a party</td>\n",
    "        <tr>\n",
    "        <tr>\n",
    "            <td>Remove the context</td>\n",
    "            <td>Cleaned up and removed the tables</td>\n",
    "        <tr>\n",
    "    </tbody>\n",
    "\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Examples:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"my_file.txt\") as my_file:\n",
    "    text = my_file.read()\n",
    "    length = len(text)\n",
    "\n",
    "print(\"The file is {} characters long.\".format(length))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example above **`open()`** does three things:\n",
    "- Sets up a context by opening a file\n",
    "- Let's you run any code you want on that file\n",
    "- Removes the context by closing the file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Using context manager**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with <context-manager>(args):\n",
    "    #Run your code here\n",
    "    #This code is running inside the context\n",
    "\n",
    "#This code runs after the context is removed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with <context-manager>(args) as <variable-name>:\n",
    "    #Run your code here\n",
    "    #This code is running inside the context\n",
    "\n",
    "#This code runs after the context is removed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Task 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "image = get_image_from_instagram()\n",
    "\n",
    "# Time how long process_with_numpy(image) takes to run\n",
    "with timer():\n",
    "  print('Numpy version')\n",
    "  process_with_numpy(image)\n",
    "\n",
    "# Time how long process_with_pytorch(image) takes to run\n",
    "with timer():\n",
    "  print('Pytorch version')\n",
    "  process_with_pytorch(image)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may have noticed there was no as `<variable name> `at the end of the with statement in timer() context manager. That is because ``timer()`` is a context manager that does not return a value, so the as `<variable name>` at the end of the with statement isn't necessary. In the next lesson, you'll learn how to write your own context managers like `timer()`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Writing context managers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Two ways to define a context manager:\n",
    "- Class-based\n",
    "- Function-based\n",
    "\n",
    "In this course we are going to focus on the later one"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Steps:**\n",
    "1) Define a function\n",
    "2) (optional) add any set up code your context needs\n",
    "3) Use the \"yield\" keyword\n",
    "4) (optional) add any teardown code your context needs\n",
    "5) Add the `contextlib.contextmanager` decorator\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@contextlib.contextmanager\n",
    "def my_context():\n",
    "    #Add any set up code you need\n",
    "    yield\n",
    "    #Add any teardown code you need"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `yield` keyword means that you want to return certain value, but at the same time you want to continue the rest of the code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import contextlib\n",
    "\n",
    "\n",
    "@contextlib.contextmanager\n",
    "def my_context():\n",
    "    print(\"hello\")\n",
    "    yield 42\n",
    "    print(\"goodbye\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "foo is 42\n",
      "goodbye\n"
     ]
    }
   ],
   "source": [
    "with my_context() as foo:\n",
    "    print(\"foo is {}\".format(foo))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@contextlib.contextmanager\n",
    "def database(url):\n",
    "    #set up database connection\n",
    "    db = postgres.connect(url)\n",
    "\n",
    "    yield db\n",
    "\n",
    "    #tear down database connection\n",
    "    db.disconnect()\n",
    "\n",
    "\n",
    "url = \"http://datacamp.com/data\"\n",
    "with database(url) as my_db:\n",
    "    course_list = my_db.execute(\n",
    "        \"SELECT * FROM courses\"\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Advanced topics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def copy(src, dist):\n",
    "    \"\"\"\"Copy the contents of one file to another\"\"\"\n",
    "\n",
    "    #Open both files\n",
    "    with open(src) as f_src:\n",
    "        with open(dst, \"w\") as f_dst:\n",
    "            #Read and write each line, one at a time\n",
    "            for line in f_src:\n",
    "                f_dst.write(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Handling error**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    ...\n",
    "    #code that migth raise an error\n",
    "except:\n",
    "    ...\n",
    "    #Do smth about the error\n",
    "finally:\n",
    "    ...\n",
    "    #this code runs no matter what"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 3: Decorators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions as objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you assign the function to a variable, you do not include the parantheses after the function name, however when you type function with parantheses - you are calling it"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first video was basically a revision of all the things functions are capbale of"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Task 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add the missing function references to the function map\n",
    "function_map = {\n",
    "  'mean': mean,\n",
    "  'std': std,\n",
    "  'minimum': minimum,\n",
    "  'maximum': maximum\n",
    "}\n",
    "\n",
    "data = load_data()\n",
    "print(data)\n",
    "\n",
    "func_name = get_user_input()\n",
    "\n",
    "# Call the chosen function and pass \"data\" as an argument\n",
    "function_map[func_name](data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Task 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_math_function(func_name):\n",
    "  if func_name == 'add':\n",
    "    def add(a, b):\n",
    "      return a + b\n",
    "    return add\n",
    "  elif func_name == 'subtract':\n",
    "    # Define the subtract() function\n",
    "    def subtract(a, b):\n",
    "      return a - b\n",
    "    return subtract\n",
    "  else:\n",
    "    print(\"I don't know that one\")\n",
    "    \n",
    "add = create_math_function('add')\n",
    "print('5 + 2 = {}'.format(add(5, 2)))\n",
    "\n",
    "subtract = create_math_function('subtract')\n",
    "print('5 - 2 = {}'.format(subtract(5, 2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scope"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scope determines which variables can be accessed at different point in the code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First looks on the local scope, if can't fint the variable - looks in the global scope and if no luck here again - lookt into a builtin scope.\n",
    "\n",
    "If have a nested function a haven't found variable inside a local scope, we will then check the nonlocal scope (parent function) and only then go to a global scope"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same way we use keyword `global x`, we can use `nonlocal x` inside a nested function if we want to update a variable that is defined inside your parent function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 50\n",
    "\n",
    "def one():\n",
    "  x = 10\n",
    "\n",
    "def two():\n",
    "  global x\n",
    "  x = 30\n",
    "\n",
    "def three():\n",
    "  x = 100\n",
    "  print(x)\n",
    "\n",
    "for func in [one, two, three]:\n",
    "  func()\n",
    "  print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The correct answer is 50, 30, 100, 50"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Closures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A closure in python is a tuple of variables that are no longer in scope, but that a funtion needs in order to run"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "def foo():\n",
    "    a = 5\n",
    "    def bar():\n",
    "        print(a)\n",
    "    return bar\n",
    "\n",
    "func = foo()\n",
    "\n",
    "func()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(func.__closure__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(func.__closure__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func.__closure__[0].cell_contents"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Decorators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A decorator is wrapper that you can place around a function that changes that function's behavior. It allows you to modify the inputs or the ouputs or even change the bahvior of the function itself"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`@double_args` is a decorator which multiplies every argument by two before passing them to the decorated function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@double_args\n",
    "def multiply(a, b):\n",
    "    return a * b\n",
    "\n",
    "multiply(1, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Decorators are just functions that take a function as an argument and return a modified version of itself"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Creating `@double_args`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def multiply(a, b):\n",
    "    return a * b\n",
    "def double_args(func):\n",
    "    return func\n",
    "new_multiply = double_args(multiply)\n",
    "\n",
    "new_multiply(1, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def multiply(a, b):\n",
    "    return a * b\n",
    "\n",
    "def double_args(func):\n",
    "    #define a new function that we can modify\n",
    "    def wrapper(a, b):\n",
    "        #For now, just call the unmodified function\n",
    "        return func(a, b)\n",
    "    #Return the new function\n",
    "    return wrapper\n",
    "\n",
    "new_multiply = double_args(multiply)\n",
    "new_multiply(1, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def multiply(a, b):\n",
    "    return a * b\n",
    "\n",
    "def double_args(func):\n",
    "    #define a new function that we can modify\n",
    "    def wrapper(a, b):\n",
    "        #Call the passed function, but double each argument\n",
    "        return func(a * 2, b * 2)\n",
    "    #Return the new function\n",
    "    return wrapper\n",
    "\n",
    "new_multiply = double_args(multiply)\n",
    "new_multiply(1, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@double_args\n",
    "def multiply(a, b):\n",
    "    return a * b\n",
    "\n",
    "# @double_args == multiply = double_args(multiply)\n",
    "\n",
    "multiply(1, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Task 1.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_function(a, b, c):\n",
    "  print(a + b + c)\n",
    "\n",
    "# Decorate my_function() with the print_args() decorator\n",
    "my_function = print_args(my_function)\n",
    "\n",
    "my_function(1, 2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Task 1.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Decorate my_function() with the print_args() decorator\n",
    "@print_args\n",
    "def my_function(a, b, c):\n",
    "  print(a + b + c)\n",
    "\n",
    "my_function(1, 2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Task 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_before_and_after(func):\n",
    "  def wrapper(*args):\n",
    "    print('Before {}'.format(func.__name__))\n",
    "    # Call the function being decorated with *args\n",
    "    func(*args)\n",
    "    print('After {}'.format(func.__name__))\n",
    "  # Return the nested function\n",
    "  return wrapper\n",
    "\n",
    "@print_before_and_after\n",
    "def multiply(a, b):\n",
    "  print(a * b)\n",
    "\n",
    "multiply(5, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The decorator `print_before_and_after()` defines a nested function `wrapper()` that calls whatever function gets passed to `print_before_and_after()`. `wrapper()` adds a little something else to the function call by printing one message before the decorated function is called and another right afterwards. Since `print_before_and_after()` returns the new `wrapper()` function, we can use it as a decorator to decorate the `multiply()` function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 4: More on Decorators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Real world examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "def timer(func):\n",
    "    \"\"\"\n",
    "    A decorator that prints how long a function took to run\n",
    "\n",
    "    Args:\n",
    "      func (callable): The function being decorated\n",
    "\n",
    "    Returns:\n",
    "      callable: The decorated function\n",
    "    \"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "def timer(func):\n",
    "    def wrapper(*args, **kwargs):\n",
    "        t_start = time.time()\n",
    "        result = func(*args, **kwargs)\n",
    "        t_total = time.time() - t_start\n",
    "        print(\"{} took {}s\".format(func.__name__, t_total))\n",
    "        return result\n",
    "    return wrapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sleep_n_seconds took 5.0036492347717285s\n"
     ]
    }
   ],
   "source": [
    "@timer\n",
    "def sleep_n_seconds(n):\n",
    "    time.sleep(n)\n",
    "\n",
    "sleep_n_seconds(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**When to use decorators:**\n",
    "- add common behavior to multiple functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Decorators and metedata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import wraps\n",
    "\n",
    "@wraps(func)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}