DataCamp Writing Functions in Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f544d5dc-0a12-46a0-81a2-24907ce468b1",
   "metadata": {},
   "source": [
    "## Writing Functions in Python\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44ffacd5-602c-46b9-a7a2-86f54a7346bd",
   "metadata": {},
   "source": [
    "# Course Description\n",
    "\n",
    "You've done your analysis, built your report, and trained a model. What's next? Well, if you want to deploy your model into production, your code will need to be more reliable than exploratory scripts in a Jupyter notebook. Writing Functions in Python will give you a strong foundation in writing complex and beautiful functions so that you can contribute research and engineering skills to your team. You'll learn useful tricks, like how to write context managers and decorators. You'll also learn best practices around how to write maintainable reusable functions with good documentation. They say that people who can do good research and write high-quality code are unicorns. Take this course and discover the magic!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee3660c7-430d-4620-ad0e-c5dede854619",
   "metadata": {},
   "source": [
    "## Best Practices\n",
    "\n",
    "The goal of this course is to transform you into a Python expert, and so the first chapter starts off with best practices when writing functions. You'll cover docstrings and why they matter and how to know when you need to turn a chunk of code into a function. You will also learn the details of how Python passes arguments to functions, as well as some common gotchas that can cause debugging headaches when calling functions.\n",
    "Play Chapter Now\n",
    "\n",
    "    Docstrings       50 xp\n",
    "    Crafting a docstring       100 xp\n",
    "    Retrieving docstrings       100 xp\n",
    "    Docstrings to the rescue!       50 xp\n",
    "    DRY and \"Do One Thing\"       50 xp\n",
    "    Extract a function       100 xp\n",
    "    Split up a function       100 xp\n",
    "    Pass by assignment       50 xp\n",
    "    Mutable or immutable?       50 xp\n",
    "    Best practice for default arguments       100 xp\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea4d81ac-cd68-4898-aef8-f2604b662267",
   "metadata": {},
   "source": [
    "## Context Managers\n",
    "\n",
    "If you've ever seen the \"with\" keyword in Python and wondered what its deal was, then this is the chapter for you! Context managers are a convenient way to provide connections in Python and guarantee that those connections get cleaned up when you are done using them. This chapter will show you how to use context managers, as well as how to write your own.\n",
    "Play Chapter Now\n",
    "\n",
    "    Using context managers       50 xp\n",
    "    The number of cats       100 xp\n",
    "    The speed of cats       100 xp\n",
    "    Writing context managers       50 xp\n",
    "    The timer() context manager       100 xp\n",
    "    A read-only open() context manager       100 xp\n",
    "    Advanced topics       50 xp\n",
    "    Context manager use cases       50 xp\n",
    "    Scraping the NASDAQ       100 xp\n",
    "    Changing the working directory       100 xp\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b88d9ac-0ec4-4cb6-ba86-79c41cd935d2",
   "metadata": {},
   "source": [
    "## Decorators\n",
    "\n",
    "Decorators are an extremely powerful concept in Python. They allow you to modify the behavior of a function without changing the code of the function itself. This chapter will lay the foundational concepts needed to thoroughly understand decorators (functions as objects, scope, and closures), and give you a good introduction into how decorators are used and defined. This deep dive into Python internals will set you up to be a superstar Pythonista.\n",
    "Play Chapter Now\n",
    "\n",
    "    Functions are objects       50 xp\n",
    "    Building a command line data app       100 xp\n",
    "    Reviewing your co-worker's code       100 xp\n",
    "    Returning functions for a math game       100 xp\n",
    "    Scope       50 xp\n",
    "    Understanding scope       50 xp\n",
    "    Modifying variables outside local scope       100 xp\n",
    "    Closures       50 xp\n",
    "    Checking for closure       100 xp\n",
    "    Closures keep your values safe       100 xp\n",
    "    Decorators       50 xp\n",
    "    Using decorator syntax       100 xp\n",
    "    Defining a decorator       100 xp\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67a8d41c-55a6-4109-8129-aa2bbf0d9590",
   "metadata": {},
   "source": [
    "## More on Decorators\n",
    "\n",
    "Now that you understand how decorators work under the hood, this chapter gives you a bunch of real-world examples of when and how you would write decorators in your own code. You will also learn advanced decorator concepts like how to preserve the metadata of your decorated functions and how to write decorators that take arguments.\n",
    "Play Chapter Now\n",
    "\n",
    "    Real-world examples       50 xp\n",
    "    Print the return type       100 xp\n",
    "    Counter       100 xp\n",
    "    Decorators and metadata       50 xp\n",
    "    Preserving docstrings when decorating functions       100 xp\n",
    "    Measuring decorator overhead       100 xp\n",
    "    Decorators that take arguments       50 xp\n",
    "    Run_n_times()       100 xp\n",
    "    HTML Generator       100 xp\n",
    "    Timeout(): a real world example       50 xp\n",
    "    Tag your functions       100 xp\n",
    "    Check the return type       100 xp\n",
    "    Great job!       50 xp\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9164f43e-4864-461c-ba3a-7181067bb6c5",
   "metadata": {},
   "source": [
    "## Docstrings\n",
    "\n",
    "\n",
    "**You've probably spent a lot of time using functions that someone else wrote, in this course, you'll learn how to write functions that others can use.  \n",
    "\n",
    "\n",
    "Docstrings are a Python best practice that will make your code much easier to use, read, and maintain.  Just look at below function, if you wanted to understand what the function does, what are the arguments supposed to be, and what it returns, you would have to spend sometime deciphering the code.  With a docstring though, it is much easier to tell what the expected inputs and outputs should be, as well as what the function does.  This makes it easier for you and other engineers to use your code in the future.  \n",
    "\n",
    "A docstring is a string written as the first line of a function, because docstring usually span multiple lines, they are enclosed with triple quotes - Python's way of writing multi-line strings.  Every docstring has some although usually not all of these 5 key pieces of information  \n",
    "\n",
    "\n",
    "\n",
    "It should be imperative language:\n",
    "    for example: split the dataframe and stack the columns.\n",
    "    instead of \"this function will split the dataframe and stack the columns\"\n",
    "\n",
    "'''\n",
    "1, description of what the function does,\n",
    "2, description of the arguments, if any,\n",
    "3, description of return values, if any,\n",
    "4, descriptions of error raised, if any,\n",
    "5, optional extra notes or example of useage.\n",
    "'''\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d10e50c-b66a-4f04-958b-e3fcc4a2cc0a",
   "metadata": {},
   "source": [
    "# *******************************************************************************************************************\n",
    "When would we need to use below function? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "34baa86b-9de3-4826-a818-a0a32e670e59",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Team  League  Year   RS   RA   W    G  Playoffs\n",
      "0     1      26  2012  734  688  81  162         0\n",
      "1     2      25  2012  700  600  94  162         1\n",
      "2     3      18  2012  712  705  93  162         1\n",
      "3     5      18  2012  734  806  69  162         0\n",
      "4    15      18  2012  613  759  61  162         0\n",
      "\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "\n",
      "   name1  name2  name3  name4\n",
      "0      1     26   2012    734\n",
      "1      2     25   2012    700\n",
      "2      3     18   2012    712\n",
      "3      5     18   2012    734\n",
      "4     15     18   2012    613\n",
      "5    688     81    162      0\n",
      "6    600     94    162      1\n",
      "7    705     93    162      1\n",
      "8    806     69    162      0\n",
      "9    759     61    162      0\n"
     ]
    }
   ],
   "source": [
    "def split_and_stack(df, new_names):\n",
    "    '''\n",
    "    Split a DataFrame's columns into two halves and then stack them vertically, \n",
    "    retuning a new DataFrame with 'new_names' as the column names.\n",
    "    \n",
    "    Args:\n",
    "        df (DataFrame): the DataFrameto split.\n",
    "        new_names (interable of str): the column names for the new DataFrame\n",
    "    \n",
    "    Returns:\n",
    "        DataFrame\n",
    "    '''\n",
    "    import numpy as np\n",
    "    import pandas as pd\n",
    "    \n",
    "    half = int(len(df.columns)/2)\n",
    "    left = df.iloc[:,:half]\n",
    "    right = df.iloc[:,half:]\n",
    "    # ************************************************************************************************************* #\n",
    "    return pd.DataFrame(\n",
    "        data = np.vstack([left.values, right.values]), \n",
    "        columns = new_names, \n",
    "        index=[i for i in range(len(df)*2)])\n",
    "\n",
    "\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "baseball_df = pd.read_csv('baseball_stats_values.csv')\n",
    "print(baseball_df)\n",
    "print()\n",
    "\n",
    "index=[i for i in range(len(baseball_df)*2)]\n",
    "print(index)\n",
    "print()\n",
    "# ***************************************************************************************************************** #\n",
    "# ***************************************************************************************************************** #\n",
    "new_names = ['name1', 'name2', 'name3', 'name4']\n",
    "new_baseball_df = split_and_stack(baseball_df, new_names)\n",
    "print(new_baseball_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60f2a188-b619-4a92-b987-0aad264155e8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "my_df = pd.read_csv('baseball_stats.csv')\n",
    "\n",
    "print(len(my_df))\n",
    "#print(dir(my_df))\n",
    "\n",
    "\n",
    "#print(help(np.vstack))\n",
    "#print(help(pd.DataFrame))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d22e0258-f40c-4e70-9599-7f495c3efec0",
   "metadata": {},
   "outputs": [],
   "source": [
    "Google style:\n",
    "#####################################################################################################################\n",
    "    \n",
    "    \n",
    "def function(arg_1, arg_2=42):\n",
    "    '''Description of what the function does\n",
    "    \n",
    "    Args:\n",
    "      arg_1 (str): Description of arg_1 that can be break into next line if needed.\n",
    "      arg_2 (int, optional): Write optional when an argument has a default value\n",
    "      \n",
    "    Returns:\n",
    "      bool: Optional description of the return value\n",
    "      Extra lines are not indented\n",
    "      \n",
    "    Raise:\n",
    "      ValueError: Include any error types that the fuction intentional raise\n",
    "      \n",
    "    Notes:\n",
    "      see https:www.datacamp.com/community/tutorials/docstrings-python\n",
    "      for more info\n",
    "    '''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d0a25b5-5d68-4d87-8ff9-189006945306",
   "metadata": {},
   "outputs": [],
   "source": [
    "Numpydoc style:\n",
    "#####################################################################################################################\n",
    "    \n",
    "    \n",
    "def function(arg_1, arg_2=42):\n",
    "    \n",
    "    '''\n",
    "    Description of what the function does\n",
    "    \n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    arg_1 : expected type of arg_1\n",
    "      Description of arg_1\n",
    "    arg_2 : int, optional\n",
    "      Write optional when an argument has a default value\n",
    "      Default=42\n",
    "      \n",
    "      \n",
    "    Returns\n",
    "    -------\n",
    "    The type of the return value\n",
    "      Can include a description of the return value\n",
    "      Replace \"Return\" with \"Yields\" if the function is a generator\n",
    "    \n",
    "    '''"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82c8fa2c-d357-4d3a-bc4e-52e2ff6ec9e8",
   "metadata": {},
   "source": [
    "**Sometimes it is useful for your code to access the content of your function's docstring.  \n",
    "\n",
    "# Every function in Python comes with a __doc__ attribute that holds this information.  \n",
    "\n",
    "Notice that the __doc__ attribute contains the raw docstring, including any tabs or spaces that were added to make the words line up visually.  To get a clearner version with those leading spaces removed, you can use the getdoc() function from the inspect module.  The inspect module contains a lot of useful methods for gathering information about functions.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "b8182bb3-cf3c-4250-9b23-5f460f8c4a1c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Return the answer to life, the universe, and everything\n",
      "    \n",
      "    Returns:\n",
      "      int\n",
      "    \n",
      "Return the answer to life, the universe, and everything\n",
      "\n",
      "Returns:\n",
      "  int\n"
     ]
    }
   ],
   "source": [
    "# Retrieving docstrings\n",
    "\n",
    "\n",
    "def the_answer():\n",
    "    '''Return the answer to life, the universe, and everything\n",
    "    \n",
    "    Returns:\n",
    "      int\n",
    "    '''\n",
    "    return 42\n",
    "\n",
    "\n",
    "\n",
    "print(the_answer.__doc__)\n",
    "\n",
    "\n",
    "import inspect\n",
    "\n",
    "print(inspect.getdoc(the_answer))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b525cda-d6b8-401f-a6b1-06eef3286ddd",
   "metadata": {},
   "source": [
    "## Crafting a docstring\n",
    "\n",
    "You've decided to write the world's greatest open-source natural language processing Python package. It will revolutionize working with free-form text, the way numpy did for arrays, pandas did for tabular data, and scikit-learn did for machine learning.\n",
    "\n",
    "The first function you write is count_letter(). It takes a string and a single letter and returns the number of times the letter appears in the string. You want the users of your open-source package to be able to understand how this function works easily, so you will need to give it a docstring. Build up a Google Style docstring for this function by following these steps.\n",
    "\n",
    "    1 Question\n",
    "    Copy the following string and add it as the docstring for the function: Count the number of times `letter` appears in `content`.\n",
    "    \n",
    "    \n",
    "    \n",
    "    2 Question\n",
    "    Now add the arguments section, using the Google style for docstrings. Use str to indicate a string.\n",
    "    \n",
    "    \n",
    "    \n",
    "    3 QUestion\n",
    "    Add a returns section that informs the user the return value is an int.\n",
    "    \n",
    "    \n",
    "    \n",
    "    4 QUestion\n",
    "    Finally, add some information about the ValueError that gets raised when the arguments aren't correct.\n",
    "    \n",
    "    What a delightful docstring! While it does require a bit more typing, the information presented here will make it very easy for others to use this code in the future. Remember that even though computers execute it, code is actually written for humans to read (otherwise you'd just be writing the 1s and 0s that the computer operates on)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2a49d58a-1329-4a32-a494-bb9b61ba30fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_letter(content, letter):\n",
    "    \"\"\"Count the number of times `letter` appears in `content`.\n",
    "    \n",
    "    # Add a Google style arguments section\n",
    "    Args:\n",
    "      content (str): The string to search.\n",
    "      letter (str): The letter to search for.\n",
    "    \"\"\"\n",
    "    if (not isinstance(letter, str)) or len(letter) != 1:\n",
    "        raise ValueError('`letter` must be a single character string.')\n",
    "    return len([char for char in content if char == letter])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b9477ef1-a8c7-46ac-b15f-ceef4db07a19",
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_letter(content, letter):\n",
    "    \"\"\"Count the number of times `letter` appears in `content`.\n",
    "  \n",
    "    Args:\n",
    "      content (str): The string to search.\n",
    "      letter (str): The letter to search for.\n",
    "  \n",
    "    # Add a returns section\n",
    "    Returns:\n",
    "      int\n",
    "    \"\"\"\n",
    "    if (not isinstance(letter, str)) or len(letter) != 1:\n",
    "        raise ValueError('\"letter\" must be a single character string.')\n",
    "    return len([char for char in content if char == letter])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70f286a7-1224-4a3a-a567-1568cde57373",
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_letter(content, letter):\n",
    "    \"\"\"Count the number of times `letter` appears in `content`.\n",
    "  \n",
    "    Args:\n",
    "      content (str): The string to search.\n",
    "      letter (str): The letter to search for.\n",
    "  \n",
    "    Returns:\n",
    "      int\n",
    "  \n",
    "    # Add a section detailing what errors might be raised\n",
    "    Raises:\n",
    "      ValueError: If `letter` is not a one-character string.\n",
    "    \"\"\"\n",
    "    if (not isinstance(letter, str)) or len(letter) != 1:\n",
    "        raise ValueError('`letter` must be a single character string.')\n",
    "    return len([char for char in content if char == letter])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "2b140518-5d2d-4f14-8a97-a16a1a4b9385",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "\n",
      "    Count the number of times 'letter' appears in 'content'\n",
      "    \n",
      "    Args:\n",
      "      content (sentence str): The paragraph content of a doc or article\n",
      "      letter (one element str): Any letter of 26 letters in alphabet\n",
      "      \n",
      "    Return:\n",
      "      int: The times letter appeaded in whole content\n",
      "      \n",
      "    Raise:\n",
      "      ValueError: Letter should be one character string\n",
      "      \n",
      "    Note:\n",
      "      see https://campus.datacamp.com/courses/writing-functions-in-python/best-practices?ex=2\n",
      "      for more info\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "# Add a docstring to count_letter()\n",
    "def count_letter(content, letter):\n",
    "    '''\n",
    "    Count the number of times 'letter' appears in 'content'\n",
    "    \n",
    "    Args:\n",
    "      content (sentence str): The paragraph content of a doc or article\n",
    "      letter (one element str): Any letter of 26 letters in alphabet\n",
    "      \n",
    "    Return:\n",
    "      int: The times letter appeaded in whole content\n",
    "      \n",
    "    Raise:\n",
    "      ValueError: Letter should be one character string\n",
    "      \n",
    "    Note:\n",
    "      see https://campus.datacamp.com/courses/writing-functions-in-python/best-practices?ex=2\n",
    "      for more info\n",
    "    '''\n",
    "    \n",
    "    if (not isinstance(letter, str)) or len(letter) != 1:\n",
    "        raise ValueError('`letter` must be a single character string.')\n",
    "    return len([char for char in content if char == letter])\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "a = 'A static method in Java does not translate to a Python classmethod. Oh sure, \\\n",
    "it results in more or less the same effect, but the goal of a classmethod is actually \\\n",
    "to do something that’s usually not even possible in Java (like inheriting a non-default \\\n",
    "constructor). The idiomatic translation of a Java static method is usually a module-level \\\n",
    "function, not a classmethod or staticmethod. (And static final fields should translate to \\\n",
    "module-level constants.)'\n",
    "\n",
    "print(count_letter(a,letter = 'f'))\n",
    "\n",
    "\n",
    "print(count_letter.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b47410c9-b35b-444d-9f2c-519498ed35f6",
   "metadata": {},
   "source": [
    "## Retrieving docstrings\n",
    "\n",
    "You and a group of friends are working on building an amazing new Python IDE (integrated development environment -- like PyCharm, Spyder, Eclipse, Visual Studio, etc.). The team wants to add a feature that displays a tooltip with a function's docstring whenever the user starts typing the function name. That way, the user doesn't have to go elsewhere to look up the documentation for the function they are trying to use. You've been asked to complete the build_tooltip() function that retrieves a docstring from an arbitrary function.\n",
    "\n",
    "You will be reusing the count_letter() function that you developed in the last exercise to show that we can properly extract its docstring.\n",
    "Instructions 1/3\n",
    "0 XP\n",
    "\n",
    "    1 Question\n",
    "    Begin by getting the docstring for the function count_letter(). Use an attribute of the count_letter() function.\n",
    "    \n",
    "    \n",
    "    \n",
    "    2 Question\n",
    "    Now use a function from the inspect module to get a better-formatted version of count_letter()'s docstring.\n",
    "    \n",
    "    \n",
    "    \n",
    "    3 Question\n",
    "    Now create a build_tooltip() function that can extract the docstring from any function that we pass to it.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f20ff31f-ffcc-4480-ad8e-d9521f6e1fbe",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the \"count_letter\" docstring by using an attribute of the function\n",
    "docstring = count_letter.__doc__\n",
    "\n",
    "border = '#' * 28\n",
    "print('{}\\n{}\\n{}'.format(border, docstring, border))\n",
    "\n",
    "\n",
    "import inspect\n",
    "\n",
    "# Inspect the count_letter() function to get its docstring\n",
    "docstring = inspect.getdoc(count_letter)\n",
    "\n",
    "border = '#' * 28\n",
    "print('{}\\n{}\\n{}'.format(border, docstring, border))\n",
    "\n",
    "\n",
    "import inspect\n",
    "\n",
    "def build_tooltip(function):\n",
    "    \"\"\"Create a tooltip for any function that shows the\n",
    "    function's docstring.\n",
    "  \n",
    "    Args:\n",
    "      function (callable): The function we want a tooltip for.\n",
    "  \n",
    "    Returns:\n",
    "      str\n",
    "    \"\"\"\n",
    "    # Get the docstring for the \"function\" argument by using inspect\n",
    "    docstring = inspect.getdoc(function)\n",
    "    border = '#' * 28\n",
    "    return '{}\\n{}\\n{}'.format(border, docstring, border)\n",
    "\n",
    "print(build_tooltip(count_letter))\n",
    "print(build_tooltip(range))\n",
    "print(build_tooltip(print))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "df171b34-936d-4a17-9cf2-bafc76bfd9e5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "33\n",
      "['ArgInfo', 'ArgSpec', 'Arguments', 'Attribute', 'BlockFinder', 'BoundArguments', 'CORO_CLOSED', 'CORO_CREATED', 'CORO_RUNNING', 'CORO_SUSPENDED', 'CO_ASYNC_GENERATOR', 'CO_COROUTINE', 'CO_GENERATOR', 'CO_ITERABLE_COROUTINE', 'CO_NESTED', 'CO_NEWLOCALS', 'CO_NOFREE', 'CO_OPTIMIZED', 'CO_VARARGS', 'CO_VARKEYWORDS', 'ClassFoundException', 'ClosureVars', 'EndOfBlock', 'FrameInfo', 'FullArgSpec', 'GEN_CLOSED', 'GEN_CREATED', 'GEN_RUNNING', 'GEN_SUSPENDED', 'OrderedDict', 'Parameter', 'Signature', 'TPFLAGS_IS_ABSTRACT', 'Traceback', '_ClassFinder', '_ClassMethodWrapper', '_KEYWORD_ONLY', '_MethodWrapper', '_NonUserDefinedCallables', '_PARAM_NAME_MAPPING', '_POSITIONAL_ONLY', '_POSITIONAL_OR_KEYWORD', '_ParameterKind', '_VAR_KEYWORD', '_VAR_POSITIONAL', '_WrapperDescriptor', '__author__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_check_class', '_check_instance', '_empty', '_filesbymodname', '_findclass', '_finddoc', '_has_code_flag', '_is_type', '_main', '_missing_arguments', '_sentinel', '_shadowed_dict', '_signature_bound_method', '_signature_from_builtin', '_signature_from_callable', '_signature_from_function', '_signature_fromstr', '_signature_get_bound_param', '_signature_get_partial', '_signature_get_user_defined_method', '_signature_is_builtin', '_signature_is_functionlike', '_signature_strip_non_python_syntax', '_static_getmro', '_too_many', '_void', 'abc', 'ast', 'attrgetter', 'builtins', 'classify_class_attrs', 'cleandoc', 'collections', 'currentframe', 'dis', 'enum', 'findsource', 'formatannotation', 'formatannotationrelativeto', 'formatargspec', 'formatargvalues', 'functools', 'getabsfile', 'getargs', 'getargspec', 'getargvalues', 'getattr_static', 'getblock', 'getcallargs', 'getclasstree', 'getclosurevars', 'getcomments', 'getcoroutinelocals', 'getcoroutinestate', 'getdoc', 'getfile', 'getframeinfo', 'getfullargspec', 'getgeneratorlocals', 'getgeneratorstate', 'getinnerframes', 'getlineno', 'getmembers', 'getmodule', 'getmodulename', 'getmro', 'getouterframes', 'getsource', 'getsourcefile', 'getsourcelines', 'importlib', 'indentsize', 'isabstract', 'isasyncgen', 'isasyncgenfunction', 'isawaitable', 'isbuiltin', 'isclass', 'iscode', 'iscoroutine', 'iscoroutinefunction', 'isdatadescriptor', 'isframe', 'isfunction', 'isgenerator', 'isgeneratorfunction', 'isgetsetdescriptor', 'ismemberdescriptor', 'ismethod', 'ismethoddescriptor', 'ismodule', 'isroutine', 'istraceback', 'itertools', 'k', 'linecache', 'mod_dict', 'modulesbyfile', 'namedtuple', 'os', 're', 'signature', 'stack', 'sys', 'token', 'tokenize', 'trace', 'types', 'unwrap', 'v', 'walktree', 'warnings']\n",
      "Count the number of times 'letter' appears in 'content'\n",
      "\n",
      "Args:\n",
      "  content (str): The paragraph content of a doc or article\n",
      "  letter (str): Any letter of 26 letters in alphabet\n",
      "\n",
      "Return:\n",
      "  int: The times letter appeaded in whole content\n",
      "\n",
      "Raise:\n",
      "  ValueError: Letter should be one character string\n",
      "\n",
      "Note:\n",
      "  see https://campus.datacamp.com/courses/writing-functions-in-python/best-practices?ex=2\n",
      "  for more info\n",
      "\n",
      "\n",
      "\n",
      "    Count the number of times 'letter' appears in 'content'\n",
      "    \n",
      "    Args:\n",
      "      content (str): The paragraph content of a doc or article\n",
      "      letter (str): Any letter of 26 letters in alphabet\n",
      "  \n",
      "    Return:\n",
      "      int: The times letter appeaded in whole content\n",
      "  \n",
      "    Raise:\n",
      "      ValueError: Letter should be one character string\n",
      "  \n",
      "    Note:\n",
      "      see https://campus.datacamp.com/courses/writing-functions-in-python/best-practices?ex=2\n",
      "      for more info\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "# Add a docstring to count_letter()\n",
    "def count_letter(content, letter):\n",
    "    '''\n",
    "    Count the number of times 'letter' appears in 'content'\n",
    "    \n",
    "    Args:\n",
    "      content (str): The paragraph content of a doc or article\n",
    "      letter (str): Any letter of 26 letters in alphabet\n",
    "  \n",
    "    Return:\n",
    "      int: The times letter appeaded in whole content\n",
    "  \n",
    "    Raise:\n",
    "      ValueError: Letter should be one character string\n",
    "  \n",
    "    Note:\n",
    "      see https://campus.datacamp.com/courses/writing-functions-in-python/best-practices?ex=2\n",
    "      for more info\n",
    "    '''\n",
    "    \n",
    "    if (not isinstance(letter, str)) or len(letter) != 1:\n",
    "        raise ValueError('`letter` must be a single character string.')\n",
    "    return len([char for char in content if char == letter])\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "a = 'A static method in Java does not translate to a Python classmethod. Oh sure, \\\n",
    "it results in more or less the same effect, but the goal of a classmethod is actually \\\n",
    "to do something that’s usually not even possible in Java (like inheriting a non-default \\\n",
    "constructor). The idiomatic translation of a Java static method is usually a module-level \\\n",
    "function, not a classmethod or staticmethod. (And static final fields should translate to \\\n",
    "module-level constants.)'\n",
    "\n",
    "print(count_letter(a,letter = 's'))\n",
    "\n",
    "\n",
    "dir(count_letter)\n",
    "#?count_letter\n",
    "\n",
    "import inspect\n",
    "\n",
    "print(dir(inspect))\n",
    "\n",
    "print(inspect.getdoc(count_letter))\n",
    "print()\n",
    "print()\n",
    "print(count_letter.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e734d537-76c2-4e62-847b-8543d3b09c63",
   "metadata": {},
   "source": [
    "## Docstrings to the rescue!\n",
    "\n",
    "Some maniac has corrupted your installation of numpy! All of the functions still exist, but they've been given random names. You desperately need to call the numpy.histogram() function and you don't have time to reinstall the package. Fortunately for you, the maniac didn't think to alter the docstrings, and you know how to access them. numpy has a lot of functions in it, so we've narrowed it down to four possible functions that could be numpy.histogram() in disguise: numpy.leyud(), numpy.uqka(), numpy.fywdkxa() or numpy.jinzyxq().\n",
    "\n",
    "Examine each of these functions' docstrings in the IPython shell to determine which of them is actually numpy.histogram().\n",
    "\n",
    "\n",
    "Possible Answers\n",
    "\n",
    "    numpy.leyud()\n",
    "    numpy.uqka()\n",
    "#    numpy.fywdkxa()\n",
    "    numpy.jinzyxq()\n",
    "    \n",
    "\n",
    "Hint\n",
    "\n",
    "    To view a function's docstring, you can either use print(function_name.__doc__) or print(inspect.getdoc(function_name)).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "ba335f01-bab4-4ba1-b16f-687ce1bc3f35",
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "    Compute the histogram of a dataset.\n",
      "\n",
      "    Parameters\n",
      "    ----------\n",
      "    a : array_like\n",
      "        Input data. The histogram is computed over the flattened array.\n",
      "    bins : int or sequence of scalars or str, optional\n",
      "        If `bins` is an int, it defines the number of equal-width\n",
      "        bins in the given range (10, by default). If `bins` is a\n",
      "        sequence, it defines a monotonically increasing array of bin edges,\n",
      "        including the rightmost edge, allowing for non-uniform bin widths.\n",
      "\n",
      "        .. versionadded:: 1.11.0\n",
      "\n",
      "        If `bins` is a string, it defines the method used to calculate the\n",
      "        optimal bin width, as defined by `histogram_bin_edges`.\n",
      "\n",
      "    range : (float, float), optional\n",
      "        The lower and upper range of the bins.  If not provided, range\n",
      "        is simply ``(a.min(), a.max())``.  Values outside the range are\n",
      "        ignored. The first element of the range must be less than or\n",
      "        equal to the second. `range` affects the automatic bin\n",
      "        computation as well. While bin width is computed to be optimal\n",
      "        based on the actual data within `range`, the bin count will fill\n",
      "        the entire range including portions containing no data.\n",
      "    normed : bool, optional\n",
      "\n",
      "        .. deprecated:: 1.6.0\n",
      "\n",
      "        This is equivalent to the `density` argument, but produces incorrect\n",
      "        results for unequal bin widths. It should not be used.\n",
      "\n",
      "        .. versionchanged:: 1.15.0\n",
      "            DeprecationWarnings are actually emitted.\n",
      "\n",
      "    weights : array_like, optional\n",
      "        An array of weights, of the same shape as `a`.  Each value in\n",
      "        `a` only contributes its associated weight towards the bin count\n",
      "        (instead of 1). If `density` is True, the weights are\n",
      "        normalized, so that the integral of the density over the range\n",
      "        remains 1.\n",
      "    density : bool, optional\n",
      "        If ``False``, the result will contain the number of samples in\n",
      "        each bin. If ``True``, the result is the value of the\n",
      "        probability *density* function at the bin, normalized such that\n",
      "        the *integral* over the range is 1. Note that the sum of the\n",
      "        histogram values will not be equal to 1 unless bins of unity\n",
      "        width are chosen; it is not a probability *mass* function.\n",
      "\n",
      "        Overrides the ``normed`` keyword if given.\n",
      "\n",
      "    Returns\n",
      "    -------\n",
      "    hist : array\n",
      "        The values of the histogram. See `density` and `weights` for a\n",
      "        description of the possible semantics.\n",
      "    bin_edges : array of dtype float\n",
      "        Return the bin edges ``(length(hist)+1)``.\n",
      "\n",
      "\n",
      "    See Also\n",
      "    --------\n",
      "    histogramdd, bincount, searchsorted, digitize, histogram_bin_edges\n",
      "\n",
      "    Notes\n",
      "    -----\n",
      "    All but the last (righthand-most) bin is half-open.  In other words,\n",
      "    if `bins` is::\n",
      "\n",
      "      [1, 2, 3, 4]\n",
      "\n",
      "    then the first bin is ``[1, 2)`` (including 1, but excluding 2) and\n",
      "    the second ``[2, 3)``.  The last bin, however, is ``[3, 4]``, which\n",
      "    *includes* 4.\n",
      "\n",
      "\n",
      "    Examples\n",
      "    --------\n",
      "    >>> np.histogram([1, 2, 1], bins=[0, 1, 2, 3])\n",
      "    (array([0, 2, 1]), array([0, 1, 2, 3]))\n",
      "    >>> np.histogram(np.arange(4), bins=np.arange(5), density=True)\n",
      "    (array([0.25, 0.25, 0.25, 0.25]), array([0, 1, 2, 3, 4]))\n",
      "    >>> np.histogram([[1, 2, 1], [1, 0, 1]], bins=[0,1,2,3])\n",
      "    (array([1, 4, 1]), array([0, 1, 2, 3]))\n",
      "\n",
      "    >>> a = np.arange(5)\n",
      "    >>> hist, bin_edges = np.histogram(a, density=True)\n",
      "    >>> hist\n",
      "    array([0.5, 0. , 0.5, 0. , 0. , 0.5, 0. , 0.5, 0. , 0.5])\n",
      "    >>> hist.sum()\n",
      "    2.4999999999999996\n",
      "    >>> np.sum(hist * np.diff(bin_edges))\n",
      "    1.0\n",
      "\n",
      "    .. versionadded:: 1.11.0\n",
      "\n",
      "    Automated Bin Selection Methods example, using 2 peak random data\n",
      "    with 2000 points:\n",
      "\n",
      "    >>> import matplotlib.pyplot as plt\n",
      "    >>> rng = np.random.RandomState(10)  # deterministic random data\n",
      "    >>> a = np.hstack((rng.normal(size=1000),\n",
      "    ...                rng.normal(loc=5, scale=2, size=1000)))\n",
      "    >>> _ = plt.hist(a, bins='auto')  # arguments are passed to np.histogram\n",
      "    >>> plt.title(\"Histogram with 'auto' bins\")\n",
      "    Text(0.5, 1.0, \"Histogram with 'auto' bins\")\n",
      "    >>> plt.show()\n",
      "\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "import numpy as numpy\n",
    "\n",
    "#numpy.leyud.__doc__\n",
    "\n",
    "#numpy.uqka.__doc__\n",
    "\n",
    "#numpy.fywdkxa.__doc__\n",
    "\n",
    "#print(numpy.jinzyxq.__doc__)\n",
    "\n",
    "#print(numpy.array.__doc__)\n",
    "\n",
    "\n",
    "print(numpy.histogram.__doc__)\n",
    "# ----------------------------------------------------------------------------------------------------------------- #"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f71b01d6-9a4b-4482-a758-3481a23f4fd8",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "In [2]:\n",
    "print(numpy.leyud.__doc__)\n",
    "\n",
    "    Gives a new shape to an array without changing its data.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    a : array_like\n",
    "        Array to be reshaped.\n",
    "    newshape : int or tuple of ints\n",
    "        The new shape should be compatible with the original shape. If\n",
    "        an integer, then the result will be a 1-D array of that length.\n",
    "        One shape dimension can be -1. In this case, the value is\n",
    "        inferred from the length of the array and remaining dimensions.\n",
    "    order : {'C', 'F', 'A'}, optional\n",
    "        Read the elements of `a` using this index order, and place the\n",
    "        elements into the reshaped array using this index order.  'C'\n",
    "        means to read / write the elements using C-like index order,\n",
    "        with the last axis index changing fastest, back to the first\n",
    "        axis index changing slowest. 'F' means to read / write the\n",
    "        elements using Fortran-like index order, with the first index\n",
    "        changing fastest, and the last index changing slowest. Note that\n",
    "        the 'C' and 'F' options take no account of the memory layout of\n",
    "        the underlying array, and only refer to the order of indexing.\n",
    "        'A' means to read / write the elements in Fortran-like index\n",
    "        order if `a` is Fortran *contiguous* in memory, C-like order\n",
    "        otherwise.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    reshaped_array : ndarray\n",
    "        This will be a new view object if possible; otherwise, it will\n",
    "        be a copy.  Note there is no guarantee of the *memory layout* (C- or\n",
    "        Fortran- contiguous) of the returned array.\n",
    "\n",
    "    See Also\n",
    "    --------\n",
    "    ndarray.reshape : Equivalent method.\n",
    "\n",
    "    Notes\n",
    "    -----\n",
    "    It is not always possible to change the shape of an array without\n",
    "    copying the data. If you want an error to be raised when the data is copied,\n",
    "    you should assign the new shape to the shape attribute of the array::\n",
    "\n",
    "     >>> a = np.zeros((10, 2))\n",
    "     # A transpose makes the array non-contiguous\n",
    "     >>> b = a.T\n",
    "     # Taking a view makes it possible to modify the shape without modifying\n",
    "     # the initial object.\n",
    "     >>> c = b.view()\n",
    "     >>> c.shape = (20)\n",
    "     AttributeError: incompatible shape for a non-contiguous array\n",
    "\n",
    "    The `order` keyword gives the index ordering both for *fetching* the values\n",
    "    from `a`, and then *placing* the values into the output array.\n",
    "    For example, let's say you have an array:\n",
    "\n",
    "    >>> a = np.arange(6).reshape((3, 2))\n",
    "    >>> a\n",
    "    array([[0, 1],\n",
    "           [2, 3],\n",
    "           [4, 5]])\n",
    "\n",
    "    You can think of reshaping as first raveling the array (using the given\n",
    "    index order), then inserting the elements from the raveled array into the\n",
    "    new array using the same kind of index ordering as was used for the\n",
    "    raveling.\n",
    "\n",
    "    >>> np.reshape(a, (2, 3)) # C-like index ordering\n",
    "    array([[0, 1, 2],\n",
    "           [3, 4, 5]])\n",
    "    >>> np.reshape(np.ravel(a), (2, 3)) # equivalent to C ravel then C reshape\n",
    "    array([[0, 1, 2],\n",
    "           [3, 4, 5]])\n",
    "    >>> np.reshape(a, (2, 3), order='F') # Fortran-like index ordering\n",
    "    array([[0, 4, 3],\n",
    "           [2, 1, 5]])\n",
    "    >>> np.reshape(np.ravel(a, order='F'), (2, 3), order='F')\n",
    "    array([[0, 4, 3],\n",
    "           [2, 1, 5]])\n",
    "\n",
    "    Examples\n",
    "    --------\n",
    "    >>> a = np.array([[1,2,3], [4,5,6]])\n",
    "    >>> np.reshape(a, 6)\n",
    "    array([1, 2, 3, 4, 5, 6])\n",
    "    >>> np.reshape(a, 6, order='F')\n",
    "    array([1, 4, 2, 5, 3, 6])\n",
    "\n",
    "    >>> np.reshape(a, (3,-1))       # the unspecified value is inferred to be 2\n",
    "    array([[1, 2],\n",
    "           [3, 4],\n",
    "           [5, 6]])\n",
    "    \n",
    "In [3]:\n",
    "print(numpy.uqka.__doc__)\n",
    "\n",
    "    Returns the indices that would sort an array.\n",
    "\n",
    "    Perform an indirect sort along the given axis using the algorithm specified\n",
    "    by the `kind` keyword. It returns an array of indices of the same shape as\n",
    "    `a` that index data along the given axis in sorted order.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    a : array_like\n",
    "        Array to sort.\n",
    "    axis : int or None, optional\n",
    "        Axis along which to sort.  The default is -1 (the last axis). If None,\n",
    "        the flattened array is used.\n",
    "    kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional\n",
    "        Sorting algorithm.\n",
    "    order : str or list of str, optional\n",
    "        When `a` is an array with fields defined, this argument specifies\n",
    "        which fields to compare first, second, etc.  A single field can\n",
    "        be specified as a string, and not all fields need be specified,\n",
    "        but unspecified fields will still be used, in the order in which\n",
    "        they come up in the dtype, to break ties.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    index_array : ndarray, int\n",
    "        Array of indices that sort `a` along the specified axis.\n",
    "        If `a` is one-dimensional, ``a[index_array]`` yields a sorted `a`.\n",
    "        More generally, ``np.take_along_axis(a, index_array, axis=a)`` always\n",
    "        yields the sorted `a`, irrespective of dimensionality.\n",
    "\n",
    "    See Also\n",
    "    --------\n",
    "    sort : Describes sorting algorithms used.\n",
    "    lexsort : Indirect stable sort with multiple keys.\n",
    "    ndarray.sort : Inplace sort.\n",
    "    argpartition : Indirect partial sort.\n",
    "\n",
    "    Notes\n",
    "    -----\n",
    "    See `sort` for notes on the different sorting algorithms.\n",
    "\n",
    "    As of NumPy 1.4.0 `argsort` works with real/complex arrays containing\n",
    "    nan values. The enhanced sort order is documented in `sort`.\n",
    "\n",
    "    Examples\n",
    "    --------\n",
    "    One dimensional array:\n",
    "\n",
    "    >>> x = np.array([3, 1, 2])\n",
    "    >>> np.argsort(x)\n",
    "    array([1, 2, 0])\n",
    "\n",
    "    Two-dimensional array:\n",
    "\n",
    "    >>> x = np.array([[0, 3], [2, 2]])\n",
    "    >>> x\n",
    "    array([[0, 3],\n",
    "           [2, 2]])\n",
    "\n",
    "    >>> np.argsort(x, axis=0)  # sorts along first axis (down)\n",
    "    array([[0, 1],\n",
    "           [1, 0]])\n",
    "\n",
    "    >>> np.argsort(x, axis=1)  # sorts along last axis (across)\n",
    "    array([[0, 1],\n",
    "           [0, 1]])\n",
    "\n",
    "    Indices of the sorted elements of a N-dimensional array:\n",
    "\n",
    "    >>> ind = np.unravel_index(np.argsort(x, axis=None), x.shape)\n",
    "    >>> ind\n",
    "    (array([0, 1, 1, 0]), array([0, 0, 1, 1]))\n",
    "    >>> x[ind]  # same as np.sort(x, axis=None)\n",
    "    array([0, 2, 2, 3])\n",
    "\n",
    "    Sorting with keys:\n",
    "\n",
    "    >>> x = np.array([(1, 0), (0, 1)], dtype=[('x', '<i4'), ('y', '<i4')])\n",
    "    >>> x\n",
    "    array([(1, 0), (0, 1)],\n",
    "          dtype=[('x', '<i4'), ('y', '<i4')])\n",
    "\n",
    "    >>> np.argsort(x, order=('x','y'))\n",
    "    array([1, 0])\n",
    "\n",
    "    >>> np.argsort(x, order=('y','x'))\n",
    "    array([0, 1])\n",
    "\n",
    "    \n",
    "In [4]:\n",
    "print(numpy.fywdkxa.__doc__)\n",
    "\n",
    "    Compute the histogram of a set of data.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    a : array_like\n",
    "        Input data. The histogram is computed over the flattened array.\n",
    "    bins : int or sequence of scalars or str, optional\n",
    "        If `bins` is an int, it defines the number of equal-width\n",
    "        bins in the given range (10, by default). If `bins` is a\n",
    "        sequence, it defines the bin edges, including the rightmost\n",
    "        edge, allowing for non-uniform bin widths.\n",
    "\n",
    "        .. versionadded:: 1.11.0\n",
    "\n",
    "        If `bins` is a string, it defines the method used to calculate the\n",
    "        optimal bin width, as defined by `histogram_bin_edges`.\n",
    "\n",
    "    range : (float, float), optional\n",
    "        The lower and upper range of the bins.  If not provided, range\n",
    "        is simply ``(a.min(), a.max())``.  Values outside the range are\n",
    "        ignored. The first element of the range must be less than or\n",
    "        equal to the second. `range` affects the automatic bin\n",
    "        computation as well. While bin width is computed to be optimal\n",
    "        based on the actual data within `range`, the bin count will fill\n",
    "        the entire range including portions containing no data.\n",
    "    normed : bool, optional\n",
    "\n",
    "        .. deprecated:: 1.6.0\n",
    "\n",
    "        This is equivalent to the `density` argument, but produces incorrect\n",
    "        results for unequal bin widths. It should not be used.\n",
    "\n",
    "        .. versionchanged:: 1.15.0\n",
    "            DeprecationWarnings are actually emitted.\n",
    "\n",
    "    weights : array_like, optional\n",
    "        An array of weights, of the same shape as `a`.  Each value in\n",
    "        `a` only contributes its associated weight towards the bin count\n",
    "        (instead of 1). If `density` is True, the weights are\n",
    "        normalized, so that the integral of the density over the range\n",
    "        remains 1.\n",
    "    density : bool, optional\n",
    "        If ``False``, the result will contain the number of samples in\n",
    "        each bin. If ``True``, the result is the value of the\n",
    "        probability *density* function at the bin, normalized such that\n",
    "        the *integral* over the range is 1. Note that the sum of the\n",
    "        histogram values will not be equal to 1 unless bins of unity\n",
    "        width are chosen; it is not a probability *mass* function.\n",
    "\n",
    "        Overrides the ``normed`` keyword if given.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    hist : array\n",
    "        The values of the histogram. See `density` and `weights` for a\n",
    "        description of the possible semantics.\n",
    "    bin_edges : array of dtype float\n",
    "        Return the bin edges ``(length(hist)+1)``.\n",
    "\n",
    "\n",
    "    See Also\n",
    "    --------\n",
    "    histogramdd, bincount, searchsorted, digitize, histogram_bin_edges\n",
    "\n",
    "    Notes\n",
    "    -----\n",
    "    All but the last (righthand-most) bin is half-open.  In other words,\n",
    "    if `bins` is::\n",
    "\n",
    "      [1, 2, 3, 4]\n",
    "\n",
    "    then the first bin is ``[1, 2)`` (including 1, but excluding 2) and\n",
    "    the second ``[2, 3)``.  The last bin, however, is ``[3, 4]``, which\n",
    "    *includes* 4.\n",
    "\n",
    "\n",
    "    Examples\n",
    "    --------\n",
    "    >>> np.histogram([1, 2, 1], bins=[0, 1, 2, 3])\n",
    "    (array([0, 2, 1]), array([0, 1, 2, 3]))\n",
    "    >>> np.histogram(np.arange(4), bins=np.arange(5), density=True)\n",
    "    (array([ 0.25,  0.25,  0.25,  0.25]), array([0, 1, 2, 3, 4]))\n",
    "    >>> np.histogram([[1, 2, 1], [1, 0, 1]], bins=[0,1,2,3])\n",
    "    (array([1, 4, 1]), array([0, 1, 2, 3]))\n",
    "\n",
    "    >>> a = np.arange(5)\n",
    "    >>> hist, bin_edges = np.histogram(a, density=True)\n",
    "    >>> hist\n",
    "    array([ 0.5,  0. ,  0.5,  0. ,  0. ,  0.5,  0. ,  0.5,  0. ,  0.5])\n",
    "    >>> hist.sum()\n",
    "    2.4999999999999996\n",
    "    >>> np.sum(hist * np.diff(bin_edges))\n",
    "    1.0\n",
    "\n",
    "    .. versionadded:: 1.11.0\n",
    "\n",
    "    Automated Bin Selection Methods example, using 2 peak random data\n",
    "    with 2000 points:\n",
    "\n",
    "    >>> import matplotlib.pyplot as plt\n",
    "    >>> rng = np.random.RandomState(10)  # deterministic random data\n",
    "    >>> a = np.hstack((rng.normal(size=1000),\n",
    "    ...                rng.normal(loc=5, scale=2, size=1000)))\n",
    "    >>> plt.hist(a, bins='auto')  # arguments are passed to np.histogram\n",
    "    >>> plt.title(\"Histogram with 'auto' bins\")\n",
    "    >>> plt.show()\n",
    "\n",
    "    \n",
    "In [5]:\n",
    "print(numpy.jinzyxq.__doc__)\n",
    "\n",
    "    Return an array of zeros with the same shape and type as a given array.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    a : array_like\n",
    "        The shape and data-type of `a` define these same attributes of\n",
    "        the returned array.\n",
    "    dtype : data-type, optional\n",
    "        Overrides the data type of the result.\n",
    "\n",
    "        .. versionadded:: 1.6.0\n",
    "    order : {'C', 'F', 'A', or 'K'}, optional\n",
    "        Overrides the memory layout of the result. 'C' means C-order,\n",
    "        'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,\n",
    "        'C' otherwise. 'K' means match the layout of `a` as closely\n",
    "        as possible.\n",
    "\n",
    "        .. versionadded:: 1.6.0\n",
    "    subok : bool, optional.\n",
    "        If True, then the newly created array will use the sub-class\n",
    "        type of 'a', otherwise it will be a base-class array. Defaults\n",
    "        to True.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    out : ndarray\n",
    "        Array of zeros with the same shape and type as `a`.\n",
    "\n",
    "    See Also\n",
    "    --------\n",
    "    empty_like : Return an empty array with shape and type of input.\n",
    "    ones_like : Return an array of ones with shape and type of input.\n",
    "    full_like : Return a new array with shape of input filled with value.\n",
    "    zeros : Return a new array setting values to zero.\n",
    "\n",
    "    Examples\n",
    "    --------\n",
    "    >>> x = np.arange(6)\n",
    "    >>> x = x.reshape((2, 3))\n",
    "    >>> x\n",
    "    array([[0, 1, 2],\n",
    "           [3, 4, 5]])\n",
    "    >>> np.zeros_like(x)\n",
    "    array([[0, 0, 0],\n",
    "           [0, 0, 0]])\n",
    "\n",
    "    >>> y = np.arange(3, dtype=float)\n",
    "    >>> y\n",
    "    array([ 0.,  1.,  2.])\n",
    "    >>> np.zeros_like(y)\n",
    "    array([ 0.,  0.,  0.])\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e25e4b43-0280-4b73-b98d-cf313dafc1c9",
   "metadata": {},
   "source": [
    "## DRY and \"Do One Thing\"\n",
    "\n",
    "\n",
    "\n",
    "DRY also known as dont repeat yourself, and the do one thing are good ways to ensure that your functions are well designed and easy to test.  \n",
    "\n",
    "When you are writing code to look for answers to research a question, it is totally normal to copy and paste a bit of code , tweak it slightly, and rerun it.  However, this ind of repeated code can lead to real problems.  When you undating the path and variable or somethings, it is easy to accidentally introduce errors that are hard to spot.  Another problem with repeated code is that if you want to change something, you often have to do it in multiple places.  Repeated code is a good sign that you should write a function.  \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "1ed6d112-2fff-435f-9ebc-e7cc38f05da7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "\n",
    "train = pd.read_csv('abc.csv')\n",
    "train_y = train['labels'].values\n",
    "train_x = train[[col for col in train.columns if col != 'labels']].values\n",
    "\n",
    "train_pca = PCA(n_components=2).fit_transform(train_x)\n",
    "plt.scatter(train_pca[:,0], train_pca[:,1])\n",
    "\n",
    "plt.show()\n",
    "\n",
    "\n",
    "val = pd.read_csv('abc.csv')\n",
    "val_y = val['labels'].values\n",
    "val_x = val[(col for col in val.columns if col != 'labels')].values\n",
    "\n",
    "val_pca = PCA(n_components=2).fit_transform(val_x)\n",
    "plt.scatter(val_pca[:,0], val_pca[:,1])\n",
    "\n",
    "plt.show()\n",
    "\n",
    "\n",
    "test = pd.read_csv('abc.csv')\n",
    "test_y = test['labels'].values\n",
    "test_x = test[(col for col in test.columns if col != 'labels')].values\n",
    "\n",
    "test_pca = PCA(n_components=2).fit_transform(test_x)\n",
    "plt.scatter(test_pca[:,0], test_pca[:,1])\n",
    "\n",
    "plt.show()\n",
    "\n",
    "############################################################################################\n",
    "# repeated code like this is a good sign that you should write a function, lets do this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "49e4e085-1684-48d1-8475-deaf7564030f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n"
     ]
    }
   ],
   "source": [
    "val = pd.read_csv('abc.csv')\n",
    "val_y = val['labels'].values\n",
    "val_x = val[[col for col in val.columns if col != 'labels']]   # <class 'pandas.core.frame.DataFrame'>\n",
    "\n",
    "\n",
    "print(type(val_x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53137693-b5c9-4f25-ab18-1fa3e99218de",
   "metadata": {},
   "source": [
    "# *******************************************************************************************************************\n",
    "# *******************************************************************************************************************\n",
    "What the here are we doing here?  What is this PCA for??\n",
    "\n",
    "    from sklearn.decomposition import PCA"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b9a5897-cc74-4119-8f7c-cb959b27840c",
   "metadata": {},
   "source": [
    "# Wrapping the repeated logic in a function, and then call that function several times makes it much easy to avoid the kind of errors introduced by copying and pasting.  And if you ever need to change the column info or you want to swap out PCA for some other dimensionality reduction technique, you only have to do it in one or two places.  \n",
    "\n",
    "\n",
    "However there is still a big problem with below function.  First it loads the data, then it plots the data, and then it returns the loaded data.  This function violates another software engineering principle: do one thing.  \n",
    "# Every function should have a single responsibility.  \n",
    "Instead of one big function, we could have a more nimble function that just loads the data, and second one just plotting.  \n",
    "## We get several advantages from splitting the load_and_plot() function into two smaller functions.  \n",
    "First of all, our code has become more flexible.  Say if you want to do some transformation to the data before plotting, you can do the transformation and then call the plot_data() function.  The code will also be easier for other developers to understand, and it will be more pleasant to test and debug.  Finally, if you ever need to update your code, functions that each have a single responsibility make it easier to predict how changes in one place will affect the rest of the code.  \n",
    "\n",
    "\n",
    "# Refactoring is the process of improving code by changing it a little bit at a time.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "a2e91e52-f988-47ed-bffc-c9bbf3626296",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def load_and_plot(path):\n",
    "    '''Load a data set and plot the first two principal components\n",
    "    \n",
    "    Args:\n",
    "      path (str): The location of csv file\n",
    "      \n",
    "    Returns:\n",
    "      Tuple of numpy ndarray: (features, labels)\n",
    "    '''\n",
    "    \n",
    "    import pandas as pd\n",
    "    import matplotlib.pyplot as plt\n",
    "    from sklearn.decomposition import PCA\n",
    "    \n",
    "    data = pd.read_csv(path)\n",
    "    Y = data['labels'].values\n",
    "    X = data[[col for col in data.columns if col != 'labels']].values\n",
    "    \n",
    "    pca = PCA(n_components=3).fit_transform(X)\n",
    "    plt.scatter(pca[:,0], pca[:,1])\n",
    "    plt.show()\n",
    "    \n",
    "    return X, Y\n",
    "\n",
    "\n",
    "#train_X, train_y = load_and_plot('train.csv')\n",
    "#val_X, val_y = load_and_plot('val.csv')\n",
    "#test_X, test_y = load_and_plot('test.csv')\n",
    "\n",
    "test_X, test_y = load_and_plot('abc.csv')\n",
    "\n",
    "## Wrapping the repeated logic in a function and then calling that function several times."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b4b434a-bf2a-4cf1-80d5-d832ecc70c95",
   "metadata": {},
   "source": [
    "## Every function should have one responsibility, Do One Thing principle\n",
    "\n",
    "\n",
    "\n",
    "************************** THINK"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "15a8410e-36fe-4fa0-acbe-f8f64cd32d53",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[12, 13, 11,  3, 34, 56],\n",
       "        [12, 16, 21,  9, 24, 56],\n",
       "        [22, 16, 21,  9, 24, 56],\n",
       "        [57, 26, 27, 19, 29, 26],\n",
       "        [57, 23, 17, 13, 39, 26],\n",
       "        [57, 29, 37, 13, 79, 26],\n",
       "        [23, 19, 31,  2, 74, 53],\n",
       "        [23, 29, 32, 82, 72, 13],\n",
       "        [13, 23, 12, 82, 32, 13],\n",
       "        [12, 23, 12, 83, 32, 16]]),\n",
       " array([\"'a'\", \"'c'\", \"'c'\", \"'c'\", \"'a'\", \"'b'\", \"'b'\", \"'b'\", \"'a'\",\n",
       "        \"'a'\"], dtype=object))"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def load_data(path):\n",
    "    '''Load a data set into X and y\n",
    "    \n",
    "    Args:\n",
    "      path (str): The locatio of csv file\n",
    "      \n",
    "    Returns:\n",
    "      Tuple of ndarray: (features, labels)'''\n",
    "    import pandas as pd\n",
    "    \n",
    "    df = pd.read_csv(path)\n",
    "    y = df['labels'].values\n",
    "    X = df[[i for i in list(df.columns) if i != 'labels']].values\n",
    "    \n",
    "    return X,  y\n",
    "\n",
    "\n",
    "load_data('abc.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "a5dbb2da-3b0b-4d18-9014-08c7ec2ad1ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "   col1  col2  col3  col4  col5  col6\n",
      "0    12    13    11     3    34    56\n",
      "1    12    16    21     9    24    56\n",
      "2    22    16    21     9    24    56\n",
      "3    57    26    27    19    29    26\n",
      "4    57    23    17    13    39    26\n",
      "5    57    29    37    13    79    26\n",
      "6    23    19    31     2    74    53\n",
      "7    23    29    32    82    72    13\n",
      "8    13    23    12    82    32    13\n",
      "9    12    23    12    83    32    16\n"
     ]
    }
   ],
   "source": [
    "def load_data(path):\n",
    "    '''Load csv file data into Pandas DataFrame in X and y\n",
    "    Args:\n",
    "        path: location of csv file\n",
    "    Return:\n",
    "        X, y in Pandas DataFrame format'''\n",
    "    import pandas as pd\n",
    "    \n",
    "    df = pd.read_csv(path)\n",
    "\n",
    "    y = df.loc[:, df.columns == 'labels']\n",
    "    X = df.loc[:, df.columns != 'labels']\n",
    "        \n",
    "    return X,  y\n",
    "\n",
    "\n",
    "X, y = load_data('abc.csv')\n",
    "print(type(y))\n",
    "print(X)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8eeff22-69bf-4b3a-856e-8075c9cce152",
   "metadata": {},
   "source": [
    "# *******************************************************************************************************************\n",
    "Interesting, function with no return keyword, can just plot the chart, further study is needed. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "16f64c78-de01-4466-81e7-8581b7103666",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_data(X):\n",
    "    '''Plot the first two principal components of a matrix\n",
    "    \n",
    "    Args:\n",
    "      X (numpy.ndarray): The data to plot'''\n",
    "    import matplotlib.pyplot as plt\n",
    "    from sklearn.decomposition import PCA\n",
    "    \n",
    "    pca = PCA(n_components=2).fit_transform(X)\n",
    "    plt.scatter(pca[:,0], pca[:,1])\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "plot_data(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "bfa2bd20-5c66-4ab2-ab74-0f8b54109b71",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['col1', 'col2', 'col3', 'col4', 'col5', 'col6', 'labels'], dtype='object')\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "data = pd.read_csv('abc.csv')\n",
    "print(data.columns)       #### Attribute is not method, no parentheses\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "fdf1c676-a080-4364-9374-7bad35c2f58d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['col1', 'col2', 'col3', 'col4', 'col5', 'col6', 'labels']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[12, 13, 11,  3, 34, 56],\n",
       "       [12, 16, 21,  9, 24, 56],\n",
       "       [22, 16, 21,  9, 24, 56],\n",
       "       [57, 26, 27, 19, 29, 26],\n",
       "       [57, 23, 17, 13, 39, 26],\n",
       "       [57, 29, 37, 13, 79, 26],\n",
       "       [23, 19, 31,  2, 74, 53],\n",
       "       [23, 29, 32, 82, 72, 13],\n",
       "       [13, 23, 12, 82, 32, 13],\n",
       "       [12, 23, 12, 83, 32, 16]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "data = pd.read_csv('abc.csv')\n",
    "data.columns\n",
    "print([col for col in data.columns])\n",
    "#X = data[col for col in list(data.columns) if col != 'labels'].values\n",
    "\n",
    "X = data[[col for col in list(data.columns) if col != 'labels']].values\n",
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "7d7a22e2-a8c5-4e24-bec2-dc2bac9de4b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id\n",
      " name\n",
      " job\n",
      " salary\n",
      " labels\n"
     ]
    }
   ],
   "source": [
    "for col in list(data.columns): print(col)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af8ad4c0-4891-4d61-a02b-402a74efd26a",
   "metadata": {},
   "source": [
    "## Extract a function\n",
    "\n",
    "While you were developing a model to predict the likelihood of a student graduating from college, you wrote this bit of code to get the z-scores of students' yearly GPAs. Now you're ready to turn it into a production-quality system, so you need to do something about the repetition. Writing a function to calculate the z-scores would improve this code.\n",
    "\n",
    "# Standardize the GPAs for each year\n",
    "df['y1_z'] = (df.y1_gpa - df.y1_gpa.mean()) / df.y1_gpa.std()\n",
    "df['y2_z'] = (df.y2_gpa - df.y2_gpa.mean()) / df.y2_gpa.std()\n",
    "df['y3_z'] = (df.y3_gpa - df.y3_gpa.mean()) / df.y3_gpa.std()\n",
    "df['y4_z'] = (df.y4_gpa - df.y4_gpa.mean()) / df.y4_gpa.std()\n",
    "\n",
    "Note: df is a pandas DataFrame where each row is a student with 4 columns of yearly student GPAs: y1_gpa, y2_gpa, y3_gpa, y4_gpa\n",
    "\n",
    "    Finish the function so that it returns the z-scores of a column.\n",
    "    Use the function to calculate the z-scores for each year (df['y1_z'], df['y2_z'], etc.) from the raw GPA scores (df.y1_gpa, df.y2_gpa, etc.).\n",
    "\n",
    "Hint\n",
    "\n",
    "    Notice how (df.y1_gpa - df.y1_gpa.mean()) / df.y1_gpa.std() is only performing operations on df.y1_gpa. So you should be able to pass df.y1_gpa as the column argument to the standardize() function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "8bc2e728-da6f-4fd5-a997-3f77fb093c7c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     y1_gpa    y2_gpa    y3_gpa    y4_gpa      y1_z      y2_z      y3_z  \\\n",
      "0  2.785877  2.052513  2.170544  0.065570  0.818769  0.091531  0.115777   \n",
      "1  1.144557  2.666498  0.267098  2.884737 -0.824166  0.614418 -1.399475   \n",
      "2  0.907406  0.423634  2.613459  0.030950 -1.061550 -1.295669  0.468363   \n",
      "3  2.205259  0.523580  3.984345  0.339289  0.237580 -1.210552  1.559667   \n",
      "4  2.877876  1.287922  3.077589  0.901994  0.910859 -0.559617  0.837837   \n",
      "\n",
      "       y4_z  \n",
      "0 -1.611724  \n",
      "1  0.793463  \n",
      "2 -1.641260  \n",
      "3 -1.378199  \n",
      "4 -0.898125  \n"
     ]
    }
   ],
   "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 = (column - column.mean()) / column.std()\n",
    "    return z_score\n",
    "\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "df = pd.read_csv('student_yearle_gpa.csv')\n",
    "\n",
    "\n",
    "# Use the standardize() function to calculate the z-scores\n",
    "df['y1_z'] = standardize(df.y1_gpa)\n",
    "df['y2_z'] = standardize(df.y2_gpa)\n",
    "df['y3_z'] = standardize(df.y3_gpa)\n",
    "df['y4_z'] = standardize(df.y4_gpa)\n",
    "\n",
    "print(df.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1cd362c6-5bf4-4180-b3cf-53ab7d30209c",
   "metadata": {},
   "source": [
    "## Split up a function\n",
    "\n",
    "Another engineer on your team has written this function to calculate the mean and median of a sorted list. You want to show them how to split it into two simpler functions: mean() and median()\n",
    "\n",
    "def mean_and_median(values):\n",
    "  \"\"\"Get the mean and median of a sorted list of `values`\n",
    "\n",
    "  Args:\n",
    "    values (iterable of float): A list of numbers\n",
    "\n",
    "  Returns:\n",
    "    tuple (float, float): The mean and median\n",
    "  \"\"\"\n",
    "  mean = sum(values) / len(values)\n",
    "  midpoint = int(len(values) / 2)\n",
    "  if len(values) % 2 == 0:\n",
    "    median = (values[midpoint - 1] + values[midpoint]) / 2\n",
    "  else:\n",
    "    median = values[midpoint]\n",
    "\n",
    "  return mean, median\n",
    "\n",
    "Instructions 1/2\n",
    "50 XP\n",
    "\n",
    "    1 Question\n",
    "    Write the mean() function.\n",
    "    \n",
    "    \n",
    "    \n",
    "    2 Question\n",
    "    Write the median() function.\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "7acac18a-93db-4fec-a754-f01edf93b354",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6.555555555555555, 2)"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def mean_and_median(values):\n",
    "    \"\"\"Get the mean and median of a sorted list of `values`\n",
    "\n",
    "    Args:\n",
    "      values (iterable of float): A list of numbers\n",
    "\n",
    "    Returns:\n",
    "      tuple (float, float): The mean and median\"\"\"\n",
    "    mean = sum(values) / len(values)\n",
    "    midpoint = int(len(values) / 2)\n",
    "    if len(values) % 2 == 0:\n",
    "        median = (values[midpoint - 1] + values[midpoint]) / 2\n",
    "    else:\n",
    "        median = values[midpoint]\n",
    "\n",
    "    return mean, median    # <= Why returned value data structure is tuple\n",
    "\n",
    "\n",
    "values = [1,3,4,7,2,8,9,12,13]\n",
    "mean_and_median(values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "a3d5551b-c3d9-452d-aa0d-f94c22d013de",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(62.8318, 314.159)\n"
     ]
    }
   ],
   "source": [
    "def circleInfo(r):\n",
    "    \"\"\" Return (circumference, area) of a circle of radius r \"\"\"\n",
    "    c = 2 * 3.14159 * r\n",
    "    a = 3.14159 * r * r\n",
    "    return (c, a)\n",
    "\n",
    "print(circleInfo(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "a524ed94-626c-462a-b283-9f001d106444",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def mean(values):\n",
    "    \"\"\"Get the mean of a sorted list of values\n",
    "  \n",
    "    Args:\n",
    "      values (iterable of float): A list of numbers\n",
    "  \n",
    "    Returns:\n",
    "      float\"\"\"\n",
    "    # Write the mean() function\n",
    "    mean = sum(values)/len(values)\n",
    "    return mean\n",
    "\n",
    "\n",
    "mean([1,2,3,4,5,6,7,8,9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8bd35879-fd10-45cf-b36d-524e09ad5425",
   "metadata": {},
   "outputs": [],
   "source": [
    "def median(values):\n",
    "    \"\"\"Get the median of a sorted list of values\n",
    "  \n",
    "    Args:\n",
    "      values (iterable of float): A list of numbers\n",
    "  \n",
    "    Returns:\n",
    "      float\n",
    "    \"\"\"\n",
    "    # Write the median() function\n",
    "    midpoint = int(len(values)/2)\n",
    "    if len(values)%2 == 0:\n",
    "        median = (values[midpoint-1] + values[midpoint])/2\n",
    "    else:\n",
    "        median = values[midpoint]\n",
    "    return median"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d3a991f-aea1-4004-810b-eb31976f4c13",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Pass by assignment\n",
    "\n",
    "\n",
    "\n",
    "**The way that Python passes information to functions is different from many other languages, it is referred to as pass by assignment.  lets say we have a function fool() that takes a list and set the first value of list to 99, then we set my_list to the value[1,2,3] and pass it to fool().  What do you expect the value of my_list after calling fool()?\n",
    "\n",
    "# list in Python are mutable objects, meaning that they can be changed\n",
    "\n",
    "\n",
    "**Now lets say we have another function bar(), that takes an argument and add ninety to it, then we assign the value 3 to the variable my_var, and call bar() with my_var as argument.  What do you expect the value of my_var, to be after we've called bar()?\n",
    "\n",
    "# in Python, integers are immutable, meaning they cant be changed \n",
    "\n",
    "(in that case the 4 most baisc data elements should all be immutable, string, float, integer, boolean) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "6903f6a5-45af-4257-9892-b11c96a9a533",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[90, 2, 3]\n",
      "[90, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "def fool(x):\n",
    "    x[0] = 90\n",
    "    return x\n",
    "\n",
    "\n",
    "my_list = [1,2,3]\n",
    "                         ##############################################################################\n",
    "print(fool(my_list))     # after the function was called, first element of list is changed\n",
    "print(my_list)           # and list are mutable, so original list was changed, and new obj was created"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "5c417a7b-9e9e-4f93-9ec2-114928ce225a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "93\n",
      "3\n",
      "93\n"
     ]
    }
   ],
   "source": [
    "def bar(x):\n",
    "    x = x + 90\n",
    "    return x\n",
    "    \n",
    "    \n",
    "my_var = 3\n",
    "                     #################################################################################\n",
    "print(bar(my_var))   # In this case, after function called, another object was created\n",
    "print(my_var)        # Thus the new obj - function(arg) is different object comparing with ars: my_var\n",
    "\n",
    "\n",
    "my_var = bar(my_var)\n",
    "print(my_var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "388f25c0-3fc0-45d7-8fe7-c554e127ea0d",
   "metadata": {},
   "source": [
    "# *******************************************************************************************************************\n",
    "**Lets look at another example to understand whats going on.  When we set the variable a equal to the list [1, 2, 3], the Python interpreter set the list [1, 2, 3] in a location in computer memory, and variable a is piointing to that location.  Then if we type b = a the Python set b pointing to whatever a is pointing to.  So is we append 4 to the end of a, both variables get it cause there is only one list.  Likewise, if we append 5 to b, both variables get it.  \n",
    "**However if we assign a to a different object in memory, that does not change where b is pointing to.  Now, things that happen to a are no longer happening to b, cause two variable pointing the different object in memory, with different location in memory.  \n",
    "\n",
    "\n",
    "# *******************************************************************************************************************\n",
    "When we assign a list to the variable my_list, it set up a location in memory for it.  Then when we pass my_list to the function foo(), the parameter x (or argument my_list) gets assigned to that same location in memory.  So when the function modifies the thing that x points to, it is also modifying the thing that my_list points to.  \n",
    "\n",
    "In the other example, we created a variable my_var and saaigned it the value 3.  Then we passed it the the function bar(), which caused argument x to point to the same location my_var is pointing to.  But the outcome of function bar() is another object - value 93, so pointing to aifferent location in memeort than original 3 - the variable my_var is pointing to (or we can think the function bar() is doing element-wise operation with value 3 - the location my_var variable is pointing to).  \n",
    "\n",
    "In fact, there is o way in Python to have changed x or my_var directly, cause integers are immutable variables.  \n",
    "\n",
    "\n",
    "\n",
    "a = [1, 2, 3]    <-- assign a list [1, 2, 3] to a variable a, a list is created in memory, a is point to its location\n",
    "b = a            <-- and then assign a to variable b,  Now both variable pointing to same location in memory location\n",
    "\n",
    "a[0] = 32        <-- if we change a[0] or b[0] to a new value, or assign a new value to a[0] or b[0]\n",
    "                     cause there is only one list, they are pointing to same location\n",
    "\n",
    "a = 12           <-- but if we assign a new value to a, then a changed, not point to same location wth b\n",
    "                     cause we have assign a different bject to variable b\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19ac7e7d-609c-4ccd-9d93-d44555b65445",
   "metadata": {},
   "source": [
    "**There are only a few immutable  data types  in Python because almost everything is represented as an Object. \n",
    "\n",
    "## Immutable:\n",
    "int,  float,  bool,  string,  bytes,  tuple,  frozenset,  None\n",
    "\n",
    "## Mutable:\n",
    "list,  dict,  set,  bytearray,  objects,  functions,  almost everything else\n",
    "\n",
    "\n",
    "\n",
    "# *******************************************************************************************************************\n",
    "# *******************************************************************************************************************\n",
    "# To tell something is mutable or not is to see if there is a function or method that will change the object without assigning it to a new variable.   \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "ab7edc3c-0356-4830-965c-59fdb6fa83ce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def fool(var=[]):\n",
    "    var.append(1)\n",
    "    return var\n",
    "\n",
    "\n",
    "fool()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "ff5c4aee-8249-4211-b031-f98a35ca7267",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1]"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fool()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "22c2b370-892c-4232-8fd1-fa282f381b0c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[None, 1]"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def fool(var=[None]):\n",
    "    var.append(1)\n",
    "    return var\n",
    "\n",
    "\n",
    "fool()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "0c09c099-6cc3-4443-a576-b79c0744044e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def fool(var=None):\n",
    "    var = []\n",
    "    var.append(1)\n",
    "    return var\n",
    "\n",
    "\n",
    "fool()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "736fe96c-e9d5-40bb-abcb-785132f65807",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fool()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a10cfccd-1f77-4987-bed1-db9c760faf90",
   "metadata": {},
   "source": [
    "## Mutable or immutable?\n",
    "\n",
    "The following function adds a mapping between a string and the lowercase version of that string to a dictionary. What do you expect the values of d and s to be after the function is called?\n",
    "\n",
    "def store_lower(_dict, _string):\n",
    "  \"\"\"Add a mapping between `_string` and a lowercased version of `_string` to `_dict`\n",
    "\n",
    "  Args:\n",
    "    _dict (dict): The dictionary to update.\n",
    "    _string (str): The string to add.\n",
    "  \"\"\"\n",
    "  orig_string = _string\n",
    "  _string = _string.lower()\n",
    "  _dict[orig_string] = _string\n",
    "\n",
    "d = {}\n",
    "s = 'Hello'\n",
    "\n",
    "store_lower(d, s)\n",
    "\n",
    "Answer the question\n",
    "50XP\n",
    "Possible Answers\n",
    "\n",
    "    1    d = {}, s = 'Hello'\n",
    "\n",
    "    2    d = {}, s = 'hello'\n",
    "\n",
    "    3    d = {'Hello': 'hello'}, s = 'Hello'\n",
    "\n",
    "    4    d = {'Hello': 'hello'}, s = 'hello'\n",
    "\n",
    "    5    d = {'hello': 'hello'}, s = 'hello'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "66717269-8bd8-41bf-922e-5081769256cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Hello': 'hello'}\n",
      "Hello\n"
     ]
    }
   ],
   "source": [
    "def store_lower(_dict, _string):\n",
    "    \"\"\"Add a mapping between `_string` and a lowercased version of `_string` to `_dict`\n",
    "  \n",
    "    Args:\n",
    "      _dict (dict): The dictionary to update.\n",
    "      _string (str): The string to add.\n",
    "    \"\"\"\n",
    "    orig_string = _string\n",
    "    _string = _string.lower()\n",
    "    _dict[orig_string] = _string\n",
    "\n",
    "    \n",
    "d = {}\n",
    "s = 'Hello'\n",
    "\n",
    "\n",
    "store_lower(d, s)\n",
    "\n",
    "print(d)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "670849d0-cac1-4947-b658-19351cb7bd0d",
   "metadata": {},
   "source": [
    "## Best practice for default arguments\n",
    "\n",
    "One of your co-workers (who obviously didn't take this course) has written this function for adding a column to a pandas DataFrame. Unfortunately, they used a mutable variable as a default argument value! Please show them a better way to do this so that they don't get unexpected behavior.\n",
    "\n",
    "def add_column(values, df=pandas.DataFrame()):\n",
    "  \"\"\"Add a column of `values` to a DataFrame `df`.\n",
    "  The column will be named \"col_<n>\" where \"n\" is\n",
    "  the numerical index of the column.\n",
    "\n",
    "  Args:\n",
    "    values (iterable): The values of the new column\n",
    "    df (DataFrame, optional): The DataFrame to update.\n",
    "      If no DataFrame is passed, one is created by default.\n",
    "\n",
    "  Returns:\n",
    "    DataFrame\n",
    "  \"\"\"\n",
    "  df['col_{}'.format(len(df.columns))] = values\n",
    "  return df\n",
    "\n",
    "Instructions\n",
    "100 XP\n",
    "\n",
    "    Change the default value of df to an immutable value to follow best practices.\n",
    "    Update the code of the function so that a new DataFrame is created if the caller didn't pass one.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "2e1c3528-d4a0-4949-8e6a-579f31a08f31",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>col_0</th>\n",
       "      <th>col_1</th>\n",
       "      <th>col_2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>6</td>\n",
       "      <td>6</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>7</td>\n",
       "      <td>7</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>8</td>\n",
       "      <td>8</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   col_0  col_1  col_2\n",
       "0      1      1      1\n",
       "1      2      2      2\n",
       "2      3      3      3\n",
       "3      4      4      4\n",
       "4      5      5      5\n",
       "5      6      6      6\n",
       "6      7      7      7\n",
       "7      8      8      8"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use an immutable variable for the default argument\n",
    "import pandas as pandas\n",
    "\n",
    "def better_add_column(values, df=None):\n",
    "    \"\"\"Add a column of `values` to a DataFrame `df`.\n",
    "    The column will be named \"col_<n>\" where \"n\" is\n",
    "    the numerical index of the column.\n",
    "\n",
    "    Args:\n",
    "      values (iterable): The values of the new column\n",
    "      df (DataFrame, optional): The DataFrame to update.\n",
    "        If no DataFrame is passed, one is created by default.\n",
    "\n",
    "    Returns:\n",
    "      DataFrame\"\"\"\n",
    "    # Update the function to create a default DataFrame\n",
    "    if df is None:\n",
    "        df = pandas.DataFrame()\n",
    "    df['col_{}'.format(len(df.columns))] = values\n",
    "    return df\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "values = [1,2,3,4,5,6,7,8]\n",
    "\n",
    "df = better_add_column(values)\n",
    "better_add_column(values, df)\n",
    "better_add_column(values, df)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b77debf6-ff72-4b63-864b-45470195868e",
   "metadata": {},
   "source": [
    "## Using context managers\n",
    "\n",
    "\n",
    "\n",
    "**In this lesson, I'll introduce the concept of context managers and show you how to use these special kinds of functions.  \n",
    "\n",
    "# A context manager is type of function that set up a context for your code to run in, runs your code, and then removes the context. \n",
    "\n",
    "\n",
    "Imagine that you are throwing a fancy party, and have hired some caterers to provide refreshments for your guests.  Before the party starts, the caterers set up tables with food and drinks.  Then you and your friends dance, eat, and have a good time.  When the party is done, the caterers clearn up the food and remove the tables.  In this analogy, the caterers are like context manager.  \n",
    "  \n",
    "    First, they set up a context for your party, which was a room full of food and drinks.  \n",
    "\n",
    "    Then they let you and your friends  whatever you want.  This is like you being able to run your code inside the context manager's context.  \n",
    "\n",
    "    Finally, when the party is over, the caterers clean up and remove the context that the party happened in.  \n",
    "\n",
    "\n",
    "# *******************************************************************************************************************\n",
    "**You may have used code like this before, the open() function is a context manager.  When you write with open('file_path'), it opens a file that you can read from or write to.  Then it gives control back to your code so that you can perform operations on the file object.  \n",
    "\n",
    "In this example, we read the text of the file, store the contents of the file in the variable data, and store the length of the contents in the variable length.  When the code inside the indented block is done, the open() function makes sure that the file is closed before continuing on in the script.  The print statement is outside of the context, so by the time it runs the file is closed.  \n",
    "\n",
    "\n",
    "with open(\"test.txt\") as file:   \n",
    "    data = file.read()\n",
    "    length = len(data)\n",
    "\n",
    "print(length)\n",
    "\n",
    "\n",
    "# Anytime you use a context manager, it will looks like this.  \n",
    "**The keyword with lets Python know that you are trying to enter a context.  \n",
    "**Then you call a function, you can call any function that is built to work s a context manager.  In the next lesson, I'll how you ow to write your own function that works this way.  \n",
    "**A context manager can take arguments like any other nurmal function. \n",
    "**You end the with statement with a colon as if you were writing a for loop or an if statement.  Statements in Python that have an indented block after thenm like if/else statements, function definition etc. are called compound statements.  The with statement is another type of compound statement.  Any code that you want to run inside the context that the context manager created needs to be indented.  When the indented block is done, the context manager gets a chance to clean up anything that it needs to, like when the open() context manager closed the file.  \n",
    "**Some context managers want to return a value that you can use inside the context, by adding as and a variable name at the end of with statement, you can assign the returned value to the variable name.  We used this ability when calling the open() context manager, which returns a file that we can read from or write to.  By adding as file to the with statement, we assigned the file to the variable file.  \n",
    "\n",
    "\n",
    "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\n",
    "    \n",
    "\n",
    "\n",
    "Managing Resources : In any programming language, the usage of resources like file operations or database connections is very common.  But these resources are limited in supply.  Therefore, the main problem lies in making sure to release these resources after usage.  If they are not released then it will lead to resource leakage and may cause the system to either slow down or crash.  It would be very helpful if user have a mechanism for the automatic setup and teardown of resources.  \n",
    "\n",
    "In Python, it can be achieved by the usage of context managers which facilitate the proper handling of resources.  The most common way of performing file operations is by using the with keyword as shown below:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "df62eaa4-6dae-4154-874f-98937647e977",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__iter__\n",
      "<class 'list_iterator'>\n",
      "<list_iterator object at 0x7f25529726d0>\n",
      "Managing Resources : In any programming language\n",
      " the usage of resources like file operations or database connections is very common.  But these resources are limited in supply.  Therefore\n",
      " the main problem lies in making sure to release these resources after usage.  If they are not released then it will lead to resource leakage and may cause the system to either slow down or crash.  It would be very helpful if user have a mechanism for the automatic setup and teardown of resources.  \n",
      "\n"
     ]
    },
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_2565/1930574339.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     17\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtext\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     18\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtext\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 19\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtext\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     20\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtext\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# ***************************************************************************************************************** #\n",
    "# a real world example of using context manager\n",
    "\n",
    "with open('hello.txt') as file:\n",
    "    text = file.readline()\n",
    "    print('__iter__' or '__next__' in dir(text))\n",
    "    text = text.split(',')\n",
    "    text = text.__iter__()\n",
    "    print(type(text))     # <class 'str_iterator'>\n",
    "    #length = len(text)\n",
    "    \n",
    "    \n",
    "#print('the file is {} characters long'.format(length))\n",
    "\n",
    "print(text)\n",
    "print(next(text))\n",
    "print(next(text))\n",
    "print(next(text))\n",
    "print(next(text))\n",
    "print(next(text))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "516e8ddf-4db1-4dca-8ee3-2d951f02db90",
   "metadata": {},
   "source": [
    "## The number of cats\n",
    "\n",
    "You are working on a natural language processing project to determine what makes great writers so great. Your current hypothesis is that great writers talk about cats a lot. To prove it, you want to count the number of times the word \"cat\" appears in \"Alice's Adventures in Wonderland\" by Lewis Carroll. You have already downloaded a text file, alice.txt, with the entire contents of this great book.\n",
    "\n",
    "\n",
    "Use the open() context manager to open alice.txt and assign the file to the file variable\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "id": "1f6eb44c-1d90-4689-9c13-43c8ae66a9f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lewis Carroll uses the word \"cat\" 24 times\n"
     ]
    }
   ],
   "source": [
    "# Open \"alice.txt\" and assign the file to \"file\"\n",
    "with open('alice_in_wonderland.txt') as file:\n",
    "    text = file.read()\n",
    "\n",
    "\n",
    "#######################################################################################################\n",
    "# Think back in Data Science Toolbox part 2 iterable and iterator lession.  Calling next() failed\n",
    "# should use str.split() method not str.strip(), thats why we cant call next() on  str.split() obj\n",
    "#######################################################################################################\n",
    "# File closed after the context manager, but the variable text was kept for after use\n",
    "n = 0\n",
    "for word in text.split():\n",
    "    if word.lower() in ['cat', 'cats', 'cats']:\n",
    "        n += 1\n",
    "\n",
    "print('Lewis Carroll uses the word \"cat\" {} times'.format(n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "id": "2dddaaeb-d237-48d0-8d3e-327ca1c0c9e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "148574\n",
      "3600\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[\"Alice's Adventures in Wonderland\",\n",
       " '',\n",
       " \"                ALICE'S ADVENTURES IN WONDERLAND\",\n",
       " '',\n",
       " '                          Lewis Carroll',\n",
       " '',\n",
       " '               THE MILLENNIUM FULCRUM EDITION 3.0',\n",
       " '',\n",
       " '',\n",
       " '',\n",
       " '',\n",
       " '                            CHAPTER I',\n",
       " '',\n",
       " '                      Down the Rabbit-Hole',\n",
       " '',\n",
       " '',\n",
       " '  Alice was beginning to get very tired of sitting by her sister',\n",
       " 'on the bank, and of having nothing to do:  once or twice she had',\n",
       " 'peeped into the book her sister was reading, but it had no',\n",
       " \"pictures or conversations in it, `and what is the use of a book,'\",\n",
       " \"thought Alice `without pictures or conversation?'\",\n",
       " '',\n",
       " '  So she was considering in her own mind (as well as she could,',\n",
       " 'for the hot day made her feel very sleepy and stupid), whether',\n",
       " 'the pleasure of making a daisy-chain would be worth the trouble',\n",
       " 'of getting up and picking the daisies, when suddenly a White',\n",
       " 'Rabbit with pink eyes ran close by her.',\n",
       " '',\n",
       " '  There was nothing so VERY remarkable in that; nor did Alice',\n",
       " 'think it so VERY much out of the way to hear the Rabbit say to']"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with open ('alice_in_wonderland.txt') as file:\n",
    "    text = file.read()       # Every calling file_obj.readline(), it moves one line after, like next()\n",
    "    print(type(text))        # So it usually used in a generator function, or read first n lines, \n",
    "    print(len(text))         # used after for i in range(n_line): statement, line = file.readline()\n",
    "    #print(text)             ##########################################################################\n",
    "                             ##########################################################################\n",
    "a = text.split('\\n')  ### str.split takes string as input and return string list, default ' ' separete\n",
    "# a.head()\n",
    "\n",
    "print(len(a))\n",
    "a[:30] \n",
    "\n",
    "#content  #*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "065c22d4-9e26-45a6-86e0-330ec79bb510",
   "metadata": {},
   "source": [
    "## The speed of cats\n",
    "\n",
    "You're working on a new web service that processes Instagram feeds to identify which pictures contain cats (don't ask why -- it's the internet). The code that processes the data is slower than you would like it to be, so you are working on tuning it up to run faster. Given an image, image, you have two functions that can process it:\n",
    "\n",
    "    process_with_numpy(image)\n",
    "    process_with_pytorch(image)\n",
    "\n",
    "Your colleague wrote a context manager, timer(), that will print out how long the code inside the context block takes to run. She is suggesting you use it to see which of the two options is faster. Time each function to determine which one to use in your web service.\n",
    "Instructions\n",
    "100 XP\n",
    "\n",
    "    Use the timer() context manager to time how long process_with_numpy(image) takes to run.\n",
    "    Use the timer() context manager to time how long process_with_pytorch(image) takes to run.\n",
    "\n",
    "Hint\n",
    "\n",
    "    The timer() context manager does not take any arguments.\n",
    "    The timer() context manager doesn't yield a value, so you don't need an as <variable name> in your with statement.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56629f80-b602-4f7f-948d-830d5a2313aa",
   "metadata": {},
   "source": [
    "\n",
    "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": "code",
   "execution_count": null,
   "id": "c22bb80f-4aef-49ad-962f-a4298bdeb7bc",
   "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": "code",
   "execution_count": 181,
   "id": "230cb2f8-5514-4963-969f-5823c41eb82c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bingley version\n",
      "148\n",
      "Spend: 0.05537462s to run\n",
      "Darcy version\n",
      "214\n",
      "Spend: 0.04947138s to run\n"
     ]
    }
   ],
   "source": [
    "import contextlib, time\n",
    "\n",
    "# ********************************************************************************************* #\n",
    "'''\n",
    "@contextlib.contextmanager                    #  5, @contextlib.contextmanager decorater\n",
    "def my_context():                             #  1, a function\n",
    "    # add any setup code you need             #  2, (optional) setup code\n",
    "    yield                                     #  3, yield keyword\n",
    "    # add any teardown code you need          #  4, teardown code     '''\n",
    "# ********************************************************************************************* #\n",
    "\n",
    "@contextlib.contextmanager\n",
    "def timer():\n",
    "    start = time.time()\n",
    "    try:\n",
    "        yield\n",
    "    finally:\n",
    "        t_spend = time.time() - start\n",
    "    #print(f\"Spend {t_spend} s to run\")\n",
    "    print(\"Spend: {:.7}s to run\".format(t_spend))\n",
    "\n",
    "\n",
    "\n",
    "# If the file is too big, can we apply file.readline() to solve this problem?\n",
    "def count_bingley(path, count=0):\n",
    "    with open(path, \"r\") as file:\n",
    "        content = file.read()\n",
    "        for word in content.split():\n",
    "            if word.lower() in [\"bingley\", \"bingley's\"]:\n",
    "                count += 1\n",
    "    print(count)\n",
    "    return count\n",
    "\n",
    "def count_darcy(path, count=0):\n",
    "    with open(path, \"r\") as file:\n",
    "        content = file.read()\n",
    "        for word in content.split():\n",
    "            if word.lower() in [\"darcy\", \"darcy's\"]:\n",
    "                count += 1\n",
    "    print(count)\n",
    "    return count\n",
    "\n",
    "\n",
    "path = 'Pride and Prejudice, by Jane Austen.txt'\n",
    "\n",
    "with timer():\n",
    "    print('Bingley version')\n",
    "    count_bingley(path)\n",
    "\n",
    "with timer():\n",
    "    print('Darcy version')\n",
    "    count_darcy(path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "id": "e1e1de47-1cf3-4d8d-9826-210418945d75",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8.36 ms ± 51.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "def count_cat(path, count=0):\n",
    "    \n",
    "    with open(path) as file:\n",
    "        content = file.read()\n",
    "        \n",
    "        for word in content.split():\n",
    "            if word.lower() in ['cat', 'cats']:\n",
    "                count += 1\n",
    "            \n",
    "    return count\n",
    "\n",
    "\n",
    "%timeit count_cat('alice_in_wonderland.txt')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6445a7e-941e-476d-ada1-74c240036426",
   "metadata": {},
   "source": [
    "## Writing context managers\n",
    "\n",
    "\n",
    "\n",
    "Now that you know how to use context managers, I want to show you how to write a context manager for other people to use.  There are two ways to define a context manager in Python.  \n",
    "\n",
    "Two ways to define a Context Manager in Python,  \n",
    "    __by using a class that has special __enter__() and __exit__() methods or \n",
    "    __by decorating a certain function *\n",
    "    \n",
    "    \n",
    "    \n",
    "#    How to create a context manager? There are 5 parts to creating a context manager.  \n",
    "   \n",
    "      1, first you need to define a function,\n",
    "      2, next (optional) you can add any setup code your context manager need\n",
    "      3, third you must use yield keyword to signal to Python that this is a special kind of function\n",
    "      4, after yield statement, you can add any teardown code that you need to clean up the context\n",
    "      5, finally you must decorate the function with the @contextmanager from the contextlib modele\n",
    "      "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2f88c71-5861-48e4-985b-2ae0bbaddcef",
   "metadata": {},
   "source": [
    "__yield,  it means that you are going to return a value, \n",
    "      but you expect to finish the rest of the function at some point in the future. \n",
    "\n",
    "__the value that your context manager yields can be assigned to a variable in the with statement by adding as variable name. \n",
    "\n",
    "\n",
    "\n",
    "# Some of you may recognize the yield keyword as a thing that get used when creating generators.  In fact, a context manager function is technically a generator that yield a single value\n",
    "\n",
    "\n",
    "### the ability for a function to yield control and know that it will get to finish running later is what makes context managers so useful. \n",
    "\n",
    "\n",
    "In below code box, we've assigned the value 42 that my_context() yield to the variable foo.  By running this code, you can see that after the context block is done executing, the rest of the my_context() function gets run, printing goodbye.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "id": "3b9c20a8-65dc-4e20-9e2a-323a57e93135",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "fool is 42\n",
      "goodbye\n"
     ]
    }
   ],
   "source": [
    "import contextlib\n",
    "\n",
    "@contextlib.contextmanager\n",
    "def my_context():\n",
    "    print('hello')\n",
    "    \n",
    "    yield 42\n",
    "    \n",
    "    print('goodbye')\n",
    "    \n",
    "                                     #################################################################\n",
    "with my_context() as foo:            #### running with line, context manager function runs till yield\n",
    "    print('fool is {}'.format(foo))  #### then it runs afterword with statement, after done executing\n",
    "                                     #### the rest code of context manager function gets run, goodbye\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "id": "37e3354f-ee0e-4a25-87f0-8b22e1f8b3aa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "﻿The Project Gutenberg eBook of Pride and Prejudice, by Jane Austen\n",
      "\n",
      "This eBook is for the use of anyone anywhere in the United States and\n",
      "most other parts of the world at no cost and with almost no restrictions\n",
      "whatsoever. You may copy it, give it away or re-use it under the terms\n",
      "of the Project Gutenberg License included with this eBook or online\n"
     ]
    }
   ],
   "source": [
    "from contextlib import contextmanager\n",
    "\n",
    "@contextmanager\n",
    "def CustomFileOpen(filename, method):\n",
    "    \"\"\"Custom context manager for opening a file.\"\"\"\n",
    "\n",
    "    f = open(filename, method)\n",
    "    try:\n",
    "        yield f\n",
    "    finally:\n",
    "        f.close()   # teardown code get run no mater what\n",
    "\n",
    "        \n",
    "with CustomFileOpen('Pride and Prejudice, by Jane Austen.txt', 'r') as file:\n",
    "    content = file.read()\n",
    "    \n",
    "print(content[:350])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab01a9fe-6ee5-480a-9d84-518322184a1c",
   "metadata": {},
   "source": [
    "# *******************************************************************************************************************\n",
    "\n",
    "# The ability for a function to yield control and know that it will get to finish running later is what context managers are so useful.  \n",
    "\n",
    "\n",
    "\n",
    "**Below context manager is an example of code that access a database.  \n",
    "\n",
    "Like most context managers, it has some setup code that runs before the function yields, this context manager uses that setup code to connect to the database.  \n",
    "\n",
    "Most context mangers also have some teardown  or cleanup code when they get control back after yielding, this one uses the teardown section to disconnect from the database.  \n",
    "\n",
    "This setup/teardown behavior allows a context manager to hide things like connecting and disconnecting from a database so that a programer using the context manager can just perform operations on the database without warrying about the underlying details.  \n",
    "\n",
    "\n",
    "# The database() contest manager that we've been looking at yields a specific value - the databse connection, that can be used in the context block.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "844e608b-a943-410a-af9d-9b031887b7b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import contextlib\n",
    "\n",
    "@contextlib.contextmanager\n",
    "def database(url):\n",
    "    # Setup a database connection\n",
    "    db = postgres.connect(url)    # Setup code runs before function yield, setup code connect database\n",
    "    \n",
    "    yield db\n",
    "    \n",
    "    # Teardown database connection\n",
    "    db.disconnect()               # The teardown section to disconnect from the database\n",
    "    \n",
    "    \n",
    "    \n",
    "url = 'datacamp.com/data'\n",
    "\n",
    "with database(url) as my_db:\n",
    "    course_list = my_db.execute(\n",
    "    'SELECT * FROM courses')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3fc9a2d3-46a6-45e2-bba3-d47e43d0fce0",
   "metadata": {},
   "source": [
    "# *******************************************************************************************************************\n",
    "\n",
    "# While some context manager dont yield an explicit value, in_dir() is a context manager that changes the current working directory to a specific path and then changes it back after the context block is done.  It does not need to return anything with its yield statement.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34bb9d18-9208-405a-8a2b-2749a68bd06e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import contextlib\n",
    "\n",
    "@contextlib.contextmanager\n",
    "def in_dir(path):\n",
    "    # save current working directory\n",
    "    old_dir = os.getcwd()\n",
    "    \n",
    "    # switch to new working directory\n",
    "    os.chdir(path)\n",
    "    \n",
    "    yield\n",
    "    \n",
    "    # change back to previous woring directory\n",
    "    os.chdir(old_dir)\n",
    "    \n",
    "    \n",
    "    \n",
    "with in_dir('/data/project_1/'):\n",
    "    project_files = os.listdir()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb898ad5-b6a1-4b15-a076-b159fecf8851",
   "metadata": {},
   "source": [
    "## The timer() context manager\n",
    "\n",
    "A colleague of yours is working on a web service that processes Instagram photos. Customers are complaining that the service takes too long to identify whether or not an image has a cat in it, so your colleague has come to you for help. You decide to write a context manager that they can use to time how long their functions take to run.\n",
    "Instructions\n",
    "100 XP\n",
    "\n",
    "    Add a decorator from the contextlib module to the timer() function that will make it act like a context manager.\n",
    "    Send control from the timer() function to the context block.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "id": "05e3b943-d7b4-48ad-8235-e47ba8e50598",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This should take approximately 0.25 seconds\n",
      "Elapsed: 0.2506015s\n"
     ]
    }
   ],
   "source": [
    "# Add a decorator that will make timer() a context manager\n",
    "import contextlib, time\n",
    "\n",
    "@contextlib.contextmanager\n",
    "def timer():\n",
    "    \"\"\"Time the execution of a context block.\n",
    "    \n",
    "    Yields:\n",
    "      None\n",
    "    \"\"\"\n",
    "    start = time.time()\n",
    "    # Send control back to the context block\n",
    "    \n",
    "    try:\n",
    "        yield\n",
    "    finally:\n",
    "        end = time.time()\n",
    "        print('Elapsed: {:.7f}s'.format(end - start))   \n",
    "\n",
    "    \n",
    "with timer():\n",
    "    print('This should take approximately 0.25 seconds')\n",
    "    time.sleep(0.25)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "id": "887db9ae-b4ab-42be-9399-095115db01f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cat version\n",
      "26\n",
      "Elapsed: 0.011473s\n",
      "Alice version\n",
      "233\n",
      "Elapsed: 0.0075622s\n",
      "Rabbit version\n",
      "33\n",
      "Elapsed: 0.0096905s\n"
     ]
    }
   ],
   "source": [
    "# Add a decorator that will make timer() a context manager\n",
    "import contextlib, time\n",
    "\n",
    "@contextlib.contextmanager\n",
    "def timer():\n",
    "    \"\"\"Time the execution of a context block.\n",
    "    \"\"\"\n",
    "    start = time.time()\n",
    "    # Send control back to the context block\n",
    "    yield\n",
    "    end = time.time()\n",
    "    print('Elapsed: {:.5}s'.format(end - start))\n",
    "    \n",
    "    \n",
    "\n",
    "def count_cat(path, count=0):\n",
    "    with open(path) as file:\n",
    "        content = file.read()\n",
    "        \n",
    "        for word in content.split():\n",
    "            if word.lower() in ['cat', 'cats', \"cat's\"]:\n",
    "                count += 1\n",
    "        print(count)\n",
    "    return count\n",
    "\n",
    "\n",
    "\n",
    "def count_alice(path, count=0):\n",
    "    with open(path) as file:\n",
    "        content = file.read()\n",
    "        \n",
    "        for word in content.split():\n",
    "            if word.lower() in ['alice', \"alice's\"]:\n",
    "                count += 1\n",
    "        print(count)\n",
    "    return count\n",
    "\n",
    "\n",
    "\n",
    "def count_rabbit(path, count=0):\n",
    "    with open(path) as file:\n",
    "        content = file.read()\n",
    "        \n",
    "        for word in content.split():\n",
    "            if word.lower() in [\"rabbit's\", 'rabbit']:\n",
    "                count += 1\n",
    "                \n",
    "        print(count)\n",
    "\n",
    "\n",
    "\n",
    "path = 'alice_in_wonderland.txt'\n",
    "\n",
    "# Time how long process_with_numpy(image) takes to run\n",
    "with timer():\n",
    "    print('Cat version')\n",
    "    count_cat(path)\n",
    "\n",
    "# Time how long process_with_pytorch(image) takes to run\n",
    "with timer():\n",
    "    print('Alice version')\n",
    "    count_alice(path)\n",
    "    \n",
    "# Time how long process_with_pytorch(image) takes to run\n",
    "with timer():\n",
    "    print('Rabbit version')\n",
    "    count_rabbit(path)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7af800c-dd27-45f0-80ab-cc002d5413ae",
   "metadata": {},
   "source": [
    "## A read-only open() context manager\n",
    "\n",
    "You have a bunch of data files for your next deep learning project that took you months to collect and clean. It would be terrible if you accidentally overwrote one of those files when trying to read it in for training, so you decide to create a read-only version of the open() context manager to use in your project.\n",
    "\n",
    "The regular open() context manager:\n",
    "\n",
    "    takes a filename and a mode ('r' for read, 'w' for write, or 'a' for append)\n",
    "    opens the file for reading, writing, or appending\n",
    "    yields control back to the context, along with a reference to the file\n",
    "    waits for the context to finish\n",
    "    and then closes the file before exiting\n",
    "\n",
    "Your context manager will do the same thing, except it will only take the filename as an argument and it will only open the file for reading.\n",
    "Instructions\n",
    "100 XP\n",
    "\n",
    "    Yield control from open_read_only() to the context block, ensuring that the read_only_file object gets assigned to my_file.\n",
    "    Use read_only_file's .close() method to ensure that you don't leave open files lying around.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "id": "be9b57ed-6829-47cd-8bb2-56c3673f91f0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       CHAPTER I\n",
      "\n",
      "                      Down the Rabbit-Hole\n",
      "\n",
      "\n",
      "  Alice was beginning to get very tired of sitting by her sister\n",
      "on the bank, and of having nothing to do:  once or twice she had\n",
      "peeped into the book her sister was reading, but it had no\n",
      "pictures or conversations in it, `and what is the use of a book,'\n",
      "thought Alice `without pictures or conversation?'\n",
      "\n",
      "  So she was considering in her\n"
     ]
    }
   ],
   "source": [
    "import contextlib\n",
    "\n",
    "@contextlib.contextmanager\n",
    "def open_read_only(filename):\n",
    "    \"\"\"Open a file in read-only mode.\n",
    "\n",
    "    Args:\n",
    "      filename (str): The location of the file to read\n",
    "\n",
    "    Yields:\n",
    "      file object\n",
    "    \"\"\"\n",
    "    read_only_file = open(filename, mode='r')\n",
    "    # Yield read_only_file so it can be assigned to my_file\n",
    "    \n",
    "    yield read_only_file\n",
    "    # Close read_only_file\n",
    "    read_only_file.close()\n",
    "\n",
    "        \n",
    "    \n",
    "with open_read_only('alice_in_wonderland.txt') as my_file:\n",
    "    #print(my_file.write('hello'))   # UnsupportedOperation: not writable\n",
    "    text = my_file.read()\n",
    "    print(text[200:600])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cab7443f-a96f-4f68-b44a-eab0996f25bb",
   "metadata": {},
   "source": [
    "## Advanced topics\n",
    "\n",
    "\n",
    "**You've learned a lot about using and writing context managers.  \n",
    "\n",
    "# In this lesson, we'll cover nested context, handing errors, and how to know when to create a context manager. \n",
    "Image you are immplementation this copy() function that copies the contents of one file to another file.  One way you could write this function would be to open & read the source file, read the content and stored the content file into content variable, then open & write the destination file, and write the contents into it. \n",
    "\n",
    "## This approach works fine, untill we try to copy a file that is too large to fit in memory. \n",
    "\n",
    "\n",
    "\n",
    "**The better idea would be open both file at once, and copy over one line at a time.  The file object that the open() context manager return can be iterated over in a for loop.  The statement \"for line in my_file\" will read in the contents of my_file one line at a time, untill the end of the file\n",
    "\n",
    "\n",
    "with open('abc.txt') as my_file:\n",
    "    for line in my_file:\n",
    "        # do something here\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "id": "862cf11c-62d7-4e1d-84b4-ef1cf28dd53b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def copy(src, dst):\n",
    "    \"\"\"Copy the contents of one file into another\n",
    "    \n",
    "    Args:\n",
    "      src (str): File name of source to be copied\n",
    "      dst (str): File name of new file\n",
    "    \"\"\"\n",
    "    \n",
    "    # Open the source file and read in the contents\n",
    "    with open(src, 'r') as f_src:\n",
    "        content = f_src.read()     # <= read the file to content variable\n",
    "        \n",
    "    # Open the destination file and write out the content\n",
    "    with open(dst, 'a') as f_dst:\n",
    "        f_dst.write(content)     # <= write the vontent variable into dest file\n",
    "    \n",
    "    \n",
    "    \n",
    "copy('abc.txt', 'ABC.txt')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fadb6aa2-5fd1-4230-9cd9-af9fbdb1fe91",
   "metadata": {},
   "source": [
    "**So, going back to our copy() fnction, if we could open both file at once, we could read in the source file line-by-line and write each line out to the destination as we go.  This would let us copy the file without warrying about how big it is.  \n",
    "\n",
    "In Python, nested with statements are perfectly legal, below code opens the source file and then opens the destination file inside the source file's context.  That means code that runs inside the context created by opening the destination file has access to both file objects.  So we are able to copy the file over one line at a timelike we wanted to.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "id": "64278646-0711-4f9f-8a92-3375bd756e8e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Elapsed: 0.002656698s\n"
     ]
    }
   ],
   "source": [
    "def copy(src, dst):\n",
    "    \"\"\"Copy the contents of one file into another\n",
    "    \n",
    "    Args:\n",
    "      src (str): File name of source to be copied\n",
    "      dst (str): File name of new file\n",
    "    \"\"\"\n",
    "    \n",
    "    # Open the source file and read in the contents\n",
    "    with open(src, 'r') as f_src:\n",
    "        with open(dst, 'a') as f_dst:  # Then open the destnation file inside the source file's context\n",
    "            for line in f_src:  \n",
    "                # That means the code runs inside open destionation file has access both f_sr and f_dst\n",
    "                f_dst.write(line)    \n",
    "\n",
    "\n",
    "\n",
    "import contextlib, time\n",
    "\n",
    "@contextlib.contextmanager\n",
    "def timer():    \n",
    "    start = time.time()\n",
    "    \n",
    "    yield\n",
    "    end = time.time()\n",
    "    print('Elapsed: {:.7}s'.format(end - start))\n",
    "\n",
    "\n",
    "\n",
    "with timer():\n",
    "    copy('alice_in_wonderland.txt', 'ABC.txt')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e0231d3-68d1-4324-bc4b-e7c18627aa76",
   "metadata": {},
   "source": [
    "## Handling errors\n",
    "\n",
    "\n",
    "One thing you want to think about when writting your context manager is: What happens if the programmer who uses your context manager writes code that causes an error?  Imagine you've written this function that lets someone connect to the printer.  The printer only allows one connection at a time, so it is imperative that p.dicsonnect() gets called, or else no one else will be able to print.  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03646888-0fe6-4e8c-a4f5-4977b3e7b5b3",
   "metadata": {},
   "source": [
    "## Handing errors  \n",
    "    \n",
    "## Python OOP Course notes:\n",
    "# ----------------------------------------------------------------------------------------------------------------- #\n",
    "try:\n",
    "    # try running some code or program\n",
    "    \n",
    "except ExceptionNameHere:\n",
    "    # run this code if ExceptionNameHere happened\n",
    "    \n",
    "except AnotherExceptionNameHere:\n",
    "    # run this code if AnotherExceptionNameHere happened\n",
    "    \n",
    "......\n",
    "    \n",
    "finally:        # <= this is optional\n",
    "    # this code runs no matter what, wheatehr except Exception happened or not\n",
    "    # this code block is best used for cleaning up, like closing open files. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "54569b9d-be8f-4d7e-b62c-280dff19c68c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import contextlib\n",
    "\n",
    "@contextlib.contextmanager\n",
    "def get_printer(ip):\n",
    "    p = connect_to_printer(ip)\n",
    "    \n",
    "    try:\n",
    "        yield\n",
    "        \n",
    "    finally:\n",
    "        p.disconnect()\n",
    "        print('disconnected from the printer')\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a748965-4be0-4e26-9150-da10ff69772d",
   "metadata": {},
   "source": [
    "# The solution then is to put a try statement before the yield keyword in our get_printer() context manager function, and put a finally statement before p.disconnected() call.  You can also insert a print('error message') in a except statement.  \n",
    "\n",
    "**In this case the problembic code will raise an error, and finally statement ensures the p.disconnect will get called no mater what before the error is raised.  \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# If you notice that your code is following any of these patterns, you might consider using a context manager.  For instance in this lesson we talked about Open -> Close, Connect -> DIsconnect patterns.  \n",
    "\n",
    "Open -> Close       Lock -> Release       Change -> Reset       Enter -> Exit\n",
    "Start -> Stop       Setup -> Teardown     Connect -> Disconnect\n",
    "\n",
    "\n",
    "**See if you can find other instance of these patterns in code you are familiar with.  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6755b7dc-502c-4504-97b2-83c8a1d85c86",
   "metadata": {},
   "source": [
    "# *******************************************************************************************************************"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1727e4fc-f8db-4d2f-8258-b23a75ed7bac",
   "metadata": {},
   "outputs": [],
   "source": [
    "import contextlib\n",
    "\n",
    "@contextlib.contextmanager\n",
    "def get_printer(ip):\n",
    "    p = connect_to _printer(ip)\n",
    "    \n",
    "    try:\n",
    "        yield   # Doesnt we need to yield something here? like yield p???\n",
    "        \n",
    "    finally:\n",
    "        p.disconnected()\n",
    "        print('disconnected from the printer')\n",
    "        \n",
    "        \n",
    "        \n",
    "doc = {\"text\": \"This is my text\"}\n",
    "\n",
    "                                     ##################################################################\n",
    "with get_printer(ip) as printer:     # When runing this, context manager codes runs till yield keyword\n",
    "    printer.print_page(doc[\"txt\"])   # This doc[\"txt\"] will cause an error, thus with statement stops.\n",
    "                                     # If with statement finished running, context manager function \n",
    "                                     # continue to run,  BUT error caused, so it stopped, BUT when\n",
    "                                     # running context manager function, try keyword has runned, so \n",
    "                                     # Python remember to run the finally statement, finish context"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6652a097-3849-4957-aacc-eddfc28e44d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import contextlib\n",
    "\n",
    "@contextlib.contextmanager\n",
    "def database(url):\n",
    "    # Setup a database connection\n",
    "    db = postgres.connect(url)    # Setup code runs before function yield, setup code connect database\n",
    "    \n",
    "    yield db\n",
    "    \n",
    "    # Teardown database connection\n",
    "    db.disconnect()               # The teardown section to disconnect from the database\n",
    "    \n",
    "    \n",
    "    \n",
    "url = 'datacamp.com/data'\n",
    "\n",
    "with database(url) as my_db:\n",
    "    course_list = my_db.execute(\n",
    "    'SELECT * FROM courses')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "id": "65613f1c-3233-49ca-b025-7f7890410535",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "fool is 42\n",
      "goodbye\n"
     ]
    }
   ],
   "source": [
    "import contextlib\n",
    "\n",
    "@contextlib.contextmanager\n",
    "def my_context():\n",
    "    print('hello')\n",
    "    \n",
    "    yield 42\n",
    "    \n",
    "    print('goodbye')\n",
    "    \n",
    "                                     ##################################################################\n",
    "with my_context() as foo:            #### running with line, context manager function runs till yield\n",
    "    print('fool is {}'.format(foo))  #### then it runs afterword with statement, after done executing\n",
    "                                     #### the rest code of context manager function gets run, goodbye\n",
    "                                     ##################################################################"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de635935-b927-488d-aa1a-bbe050ae962e",
   "metadata": {},
   "source": [
    "## Context manager use cases\n",
    "\n",
    "Which of the following would NOT be a good opportunity to use a context manager?\n",
    "Answer the question\n",
    "50XP\n",
    "Possible Answers\n",
    "\n",
    "    1    A function that starts a timer that keeps track of how long some block of code takes to run.\n",
    "\n",
    "#    2    A function that prints all of the prime numbers between 2 and some value n.\n",
    "\n",
    "    3    A function that connects to a smart thermostat so that it can be programmed remotely.\n",
    "\n",
    "    4    A function that prevents multiple users from updating an online spreadsheet at the same time by locking access to the spreadsheet before every operation.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 344,
   "id": "6ff3dc48-d438-4669-bfd9-db7b9ce5a7a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]\n"
     ]
    }
   ],
   "source": [
    "a = []\n",
    "n = 100\n",
    "\n",
    "for i in range(2, n):\n",
    "    for j in range(2, i):\n",
    "        if i % j == 0:\n",
    "            break\n",
    "    else:                ############################################################################# \n",
    "        a.append(i)      # Can I image what is happening behind this code arrangement\n",
    "                         # The else block just after for/while is executed only when the loop is \n",
    "print(a)                 # NOT terminated by a break statement\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 359,
   "id": "ceadc87d-82d6-46fc-b770-f771e0216688",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 5, 5, 5, 7, 7, 7, 7, 7, 9, 11, 11, 11, 11, 11, 11, 11, 11, 11, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 15, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17]\n"
     ]
    }
   ],
   "source": [
    "def find_prime(n):\n",
    "    prime = []\n",
    "    \n",
    "    for i in range(2, n):\n",
    "        for j in range(2, i):\n",
    "            if i%j == 0:\n",
    "                break\n",
    "            else:\n",
    "                pr = i\n",
    "            prime.append(pr)\n",
    "    print(prime)\n",
    "\n",
    "\n",
    "find_prime(18)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25787f86-4711-42bb-9d63-80d879f71993",
   "metadata": {},
   "source": [
    "# *******************************************************************************************************************"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 338,
   "id": "c8b719aa-78a2-48c8-9d99-a9b5565ff7d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5, 7, 11, 13, 17]\n"
     ]
    }
   ],
   "source": [
    "def find_prime(n):\n",
    "    \n",
    "    nums = []\n",
    "    for i in range(2,n):\n",
    "        for j in range(2,i):\n",
    "            #print(j)\n",
    "            if i%j == 0:\n",
    "                break\n",
    "        else:\n",
    "            nums.append(i)\n",
    "    print(nums)\n",
    "\n",
    "            \n",
    "find_prime(18)\n",
    "\n",
    "###########################################\n",
    "# i   |  j\n",
    "# ----|----------------------------------\n",
    "# 2   |  2\n",
    "# 3   |  2, 3\n",
    "# 4   |  2, 3, 4\n",
    "# 5   |  2, 3, 4, 5\n",
    "# 6   |  2, 3, 4, 5, 6\n",
    "# 7   |  2, 3, 4, 5, 6, 7\n",
    "# 8   |  2, 3, 4, 5, 6, 7, 8\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29ae6b6a-25e8-42fc-a846-e77a718b8bb0",
   "metadata": {},
   "source": [
    "# how to coding a more elegent approach? \n",
    "\n",
    "In most of the programming languages (C/C++, Java, etc), the use of else statement has been restricted with the if conditional statements.  But Python also allows us to use the else condition with for loops.\n",
    "\n",
    "A common construct is to run a loop until something is found and then to break out of the loop. The problem is that if I break out of the loop or the loop ends I need to determine which case happened. One method is to create a flag or store variable that will let me do a second test to see how the loop was exited.\n",
    "\n",
    "For example assume that I need to search through a list and process each item until a flag item is found and then stop processing. If the flag item is missing then an exception needs to be raised.\n",
    "\n",
    "Using the Python for...else construct you have\n",
    "\n",
    "for i in mylist:\n",
    "    if i == theflag:\n",
    "        break\n",
    "    process(i)\n",
    "else:\n",
    "    raise ValueError(\"List argument missing terminal flag.\")\n",
    "\n",
    "\n",
    "\n",
    "#    The else block just after for/while is executed only when the loop is NOT terminated by a break statement.\n",
    "    \n",
    "    \n",
    "    \n",
    "\n",
    "# *****************************************************************************************************\n",
    "Taking this find_prime() as a open minded test, how many approachs can I coming out?  And among them which one better\n",
    "\n",
    "# Do Not Just Finishing The Courses, Need To Learn Something"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9d9261c-0fbe-4048-962c-ba5e8a651186",
   "metadata": {},
   "source": [
    "## Scraping the NASDAQ\n",
    "\n",
    "Training deep neural nets is expensive! You might as well invest in NVIDIA stock since you're spending so much on GPUs. To pick the best time to invest, you are going to collect and analyze some data on how their stock is doing. The context manager stock('NVDA') will connect to the NASDAQ and return an object that you can use to get the latest price by calling its .price() method.\n",
    "\n",
    "You want to connect to stock('NVDA') and record 10 timesteps of price data by writing it to the file NVDA.txt.\n",
    "\n",
    "# You will notice the use of an underscore when iterating over the for loop. If this is confusing to you, don't worry. It could easily be replaced with i, if we planned to do something with it, like use it as an index. Since we won't be using it, we can use a dummy operator, _, which doesn't use any additional memory.\n",
    "Instructions\n",
    "100 XP\n",
    "\n",
    "#    Use the stock('NVDA') context manager and assign the result to nvda.\n",
    "    Open a file for writing with open('NVDA.txt', 'w') and assign the file object to f_out so you can record the price over time.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "161dcf14-9ced-49df-afdf-1b23ef84f9fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use the \"stock('NVDA')\" context manager\n",
    "# and assign the result to the variable \"nvda\"\n",
    "with stock('NVDA') as nvda:\n",
    "    # Open \"NVDA.txt\" for writing as f_out\n",
    "    with open(\"NVDA.txt\", 'w') as f_out:\n",
    "        for i in range(10):\n",
    "            value = nvda.price()\n",
    "            print('Logging ${:.2f} for NVDA'.format(value))\n",
    "            f_out.write('{:.2f}\\n'.format(value))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a0be009-d30a-478d-9c78-93bf2d944729",
   "metadata": {},
   "source": [
    "## Changing the working directory\n",
    "\n",
    "You are using an open-source library that lets you train deep neural networks on your data. Unfortunately, during training, this library writes out checkpoint models (i.e., models that have been trained on a portion of the data) to the current working directory. You find that behavior frustrating because you don't want to have to launch the script from the directory where the models will be saved.\n",
    "\n",
    "You decide that one way to fix this is to write a context manager that changes the current working directory, lets you build your models, and then resets the working directory to its original location. You'll want to be sure that any errors that occur during model training don't prevent you from resetting the working directory to its original location.\n",
    "Instructions\n",
    "100 XP\n",
    "\n",
    "    Add a statement that lets you handle any errors that might occur inside the context.\n",
    "    Add a statement that ensures os.chdir(current_dir) will be called, whether there was an error or not.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf79315b-a9b8-48dc-b077-12cf60bad640",
   "metadata": {},
   "outputs": [],
   "source": [
    "import contextlib\n",
    "\n",
    "@contextlib.contextmanager\n",
    "def in_dir(directory):\n",
    "    \"\"\"Change current working directory to `directory`,\n",
    "    allow the user to run some code, and change back.\n",
    "    \n",
    "    Args:\n",
    "      directory (str): The path to a directory to work in.\n",
    "    \"\"\"\n",
    "    \n",
    "    current_dir = os.getcwd()\n",
    "    os.chdir(directory)\n",
    "    \n",
    "    # Add code that lets you handle errors\n",
    "    try:\n",
    "        yield\n",
    "    \n",
    "    # Ensure the directory is reset, whether there was an error or not\n",
    "    finally:\n",
    "        os.chdir(current_dir)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "338a187d-711e-42ad-9b18-911dd40fff09",
   "metadata": {},
   "source": [
    "## Functions are objects\n",
    "\n",
    "\n",
    "**In this chapter, you are going to learn about decorators, a powerful way of modifying the behavior of functions.  But first we need to build up some foundational concepts that will make decorators easy to understand.  The main thing you should take away from this lession is that functions are just like any other object in Python.  They are not fundamentally different from lists, dictionaries, DataFrames, strings, integers, floats, modules or anything else in Python.  Any because functions are just another type of object, you can do anything to or with them that you would do with any other object. \n",
    "\n",
    "You can take a function and assign it to a variable, like x, then if you wanted to, you can call x() insted of call function().  It doesnt have to be a function you defined either.  You can also add functions to a list or dictionary.  We can call an element(function) of the list, and pass it arguments.  Since the 3th element of the list is a print() function, so list_of_things[2] equal to print, so list_of_things[2]('bonjour sawa') is equal to print('bonjour sawa'), thus print bonjour sawa.  We can also reference and use it as we are calling the function directly in other containers, like dict.  Check the code in below code box.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "66f37956-a48a-48f0-869f-6eedceb5ec8c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bonjour sawa\n",
      "hello world\n"
     ]
    }
   ],
   "source": [
    "list_of_things = [my_function, open, print]\n",
    "\n",
    "                                    ###################################################################\n",
    "list_of_things[2]('bonjour sawa')   # We can call an element(function) of the list, and pass it args\n",
    "\n",
    "\n",
    "my_function = next\n",
    "dict_of_things = {'mine':my_function, 'op':open, 'pt':print}\n",
    "dict_of_things['pt']('hello world')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "4cbeaf14-283e-4428-8cba-e58a4bb01470",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n",
      "hola\n"
     ]
    }
   ],
   "source": [
    "def my_function():\n",
    "    print('hello world')\n",
    "    \n",
    "def my_fu(text):\n",
    "    print(text)\n",
    "    \n",
    "    \n",
    "hell = my_function\n",
    "hell\n",
    "\n",
    "hel = my_fu\n",
    "hell()\n",
    "hel('hola')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2261712-9c37-4afc-b363-299060cc069e",
   "metadata": {},
   "source": [
    "# *****************************************************************************************************\n",
    "\n",
    "Notice that when you assign a function to a variable, you do not include the parentheses after the function name.  This is subtle but very important distinction.  When you type the function with the parentheses, you are calling that function.  However when you type function name without the parentheses, you are referencing the function.  It evaluates to a function object.  \n",
    "\n",
    "\n",
    "Since the function is just like anything else in python, you can pass it as an argument to another function.  The has_docstring() function checks to see wheather the function that is passed to it has a docstring or not.  We could define these two functions, no() and yes(), and pass them as arguments to the has_docstring() function.  \n",
    "\n",
    "\n",
    "\n",
    "def has_docstring(func):\n",
    "    \"\"\"Check to see if the function func has a docstring\n",
    "    \n",
    "    Args: \n",
    "      func (callable): A function\n",
    "      \n",
    "    Return:\n",
    "      bool\n",
    "    \n",
    "    \"\"\"\n",
    "\n",
    "    return func.__doc__ is not None\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "03006035-6191-4ebf-a186-460d67f40815",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def has_docstring(func):\n",
    "    \"\"\"Check to see if the function func has a docstring\n",
    "    \n",
    "    Args: \n",
    "      func (callable): A function\n",
    "      \n",
    "    Return:\n",
    "      bool\n",
    "    \"\"\"\n",
    "    return func.__doc__ is not None\n",
    "\n",
    "\n",
    "def no():\n",
    "    return 42\n",
    "\n",
    "def yes():\n",
    "    \"\"\"Returns the value 42\n",
    "    \"\"\"\n",
    "    return 42\n",
    "\n",
    "print(has_docstring(no))\n",
    "print(has_docstring(yes))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "fb9e3178-197a-46d9-a52a-463805b8079c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-12-01 01:57:38.628523\n",
      "datetime.datetime(2021, 12, 1, 1, 57, 38, 628523)\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "\n",
    "\n",
    "now = datetime.datetime.now()\n",
    "print(now.__str__())\n",
    "#'2020-12-27 22:28:00.324317'\n",
    "\n",
    "print(now.__repr__())\n",
    "#'datetime.datetime(2020, 12, 27, 22, 28, 0, 324317)'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "567840a1-745b-4a05-b8ed-b4100271bb5a",
   "metadata": {},
   "source": [
    "# *****************************************************************************************************\n",
    "# Recall what we have learned in Object-Oriented Programming in Python course\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "6c6e98c0-eab2-4c56-9255-6df0a95ab659",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on wrapper_descriptor:\n",
      "\n",
      "__repr__(self, /)\n",
      "    Return repr(self).\n",
      "\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "print(help(str.__repr__))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1dd9dc72-8729-4c39-95a4-ef62592a5b0a",
   "metadata": {},
   "source": [
    "## Functions can also be defined inside another function.  \n",
    "\n",
    "\n",
    "**These kinds of functions are called nested functions, although you may also hear them called inner functions, helper functions, or child functions.  \n",
    "\n",
    "\n",
    "**A nested function can make your code easy to read.  \n",
    "\n",
    "In below example, we can make that if statementeasier to read by defining an in_range() nested function.  So when runing the outer function, Python will call the nested function to juge arg x and arg y with calling of inner function, and if the inner function returns True (meaning v>4 and v<10 condition met, and inner function returns True), so ourter function if conditional statement was met, thus print(x*y) finally. \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "733f3a3e-9090-427b-b090-48bdd3984834",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45\n"
     ]
    }
   ],
   "source": [
    "def fool(x, y):\n",
    "    if x > 4 and x < 10 and y > 4 and y < 10:\n",
    "        print(x * y)\n",
    "        \n",
    "        \n",
    "        \n",
    "def fool2(x, y):        ##################################################\n",
    "    def in_range(v):    # Can you image how the code runs line bby line?\n",
    "        return v > 4 and v < 10\n",
    "    if in_range(x) and in_range(y):\n",
    "        print(x * y)\n",
    "        \n",
    "fool2(5,9)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cc057aa-745a-4202-bec0-f4d0485841f3",
   "metadata": {},
   "source": [
    "# There is also nothing stopping us from returning a function. \n",
    "\n",
    "\n",
    "# ****************************************************************************************************\n",
    "**For instance, the function get_function() creates (returns actually) a new function print_me() (which is a nested function) then returns it.  If we assign the result of calling get_function() to the variable new_func, we are assigning the return value (outer function returns a nested function) print_me function to the new_func variable.  We can then call new_func() as if it were the print_me function calling.  \n",
    "\n",
    "The way that Python treats everything as an object gives you the ability to do a lot of really complex things.  In the coming lessions, we'll dig into what this ability allows us to do.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "d9c609ac-2793-4b03-b1f6-cbb72671dcb5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "def get_function():\n",
    "    def print_me(s):\n",
    "        print(s)\n",
    "    return print_me\n",
    "\n",
    "\n",
    "get_function()   # returns an object\n",
    "\n",
    "n_fun = get_function()\n",
    "n_fun('hello')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88798025-5182-46aa-930c-df0c58dde13b",
   "metadata": {},
   "source": [
    "**Nested functions\n",
    "**Using Inner Functions: The Basics\n",
    "\n",
    "The use cases of Python inner functions are varied. You can use them to provide encapsulation and hide your functions from external access, you can write helper inner functions, and you can also create closures and decorators. In this section, you’ll learn about the former two use cases of inner functions, and in later sections, you’ll learn how to create closure factory functions and decorators.\n",
    "Providing Encapsulation\n",
    "\n",
    "A common use case of inner functions arises when you need to protect, or hide, a given function from everything happening outside of it so that the function is totally hidden from the global scope. This kind of behavior is commonly known as encapsulation.\n",
    "\n",
    "Here’s an example that highlights that concept:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27f08661-a07f-4a19-b242-263d1e469547",
   "metadata": {},
   "source": [
    "# Building Helper Inner Functions\n",
    "# *****************************************************************************************************\n",
    "\n",
    "Sometimes you have a function that performs the same chunk of code in several places within its body. For example, say you want to write a function to process a CSV file containing information about the Wi-Fi hotspots in New York City. To find the total number of hotspots in New York as well as the company that provides most of them, you create the following script:\n",
    "\n",
    "\n",
    "Here, process_hotspots() takes file as an argument. The function checks if file is a **string-based path to a physical file or a file object**. Then it calls the helper inner function most_common_provider(), which takes a file object and performs the following operations:\n",
    "\n",
    "    Read the file content into a generator that yields dictionaries using csv.DictReader.\n",
    "    Create a list of Wi-Fi providers.\n",
    "    Count the number of Wi-Fi hotspots per provider using a collections.Counter object.\n",
    "    Print a message with the retrieved information.\n",
    "\n",
    "\n",
    "\n",
    "Using Inner vs Private Helper Functions approach\n",
    "# *****************************************************************************************************\n",
    "\n",
    "Typically, you create helper inner functions like most_common_provider() when you want to provide encapsulation. You can also create inner functions if you think you’re not going to call them anywhere else apart from the containing function.\n",
    "\n",
    "Although writing your helper functions as inner functions achieves the desired result, you’ll probably be better served by extracting them as top-level functions. In this case, you could use a leading underscore (_) in the name of the function to indicate that it’s private to the current module or class. This will allow you to access your helper functions from anywhere else in the current module or class and reuse them as needed.\n",
    "\n",
    "Extracting inner functions into top-level private functions can make your code cleaner and more readable. This practice can produce functions that consequently apply the single-responsibility principle.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "fb10c751-cc4c-4c9c-a7ec-7c6a38bdb959",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "355687428096000"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ***************************************************************************************************************** #\n",
    "def factorial(number):\n",
    "    # Validate input\n",
    "    if not isinstance(number, int):\n",
    "        raise TypeError(\"Sorry. 'number' must be an integer.\")\n",
    "    if number < 0:\n",
    "        raise ValueError(\"Sorry. 'number' must be zero or positive.\")\n",
    "    \n",
    "    # Calculate the factorial of number\n",
    "    def inner_factorial(number):\n",
    "        if number <= 1:\n",
    "            return 1\n",
    "        return number * inner_factorial(number - 1)\n",
    "    \n",
    "    return inner_factorial(number)\n",
    "\n",
    "                 #######################################################\n",
    "factorial(17)    # Unsuccessful approach, cant handle values over 1000\n",
    "#factorial('hello')\n",
    "#factorial(-7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "01bd6e0d-a890-4cfe-aaaa-a1d7f938a2cf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "355687428096000"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ***************************************************************************************************************** #\n",
    "def factorial(number):\n",
    "    # Validate input\n",
    "    if not isinstance(number, int):\n",
    "        raise TypeError(\"Sorry. 'number' must be an integer.\")\n",
    "    if number < 0:\n",
    "        raise ValueError(\"Sorry. 'number' must be zero or positive.\")\n",
    "    \n",
    "    # Calculate the factorial of number\n",
    "    def inner_factorial(number):\n",
    "        if number <= 1:\n",
    "            return 1\n",
    "        for i in range(2,number):\n",
    "            number = number * i\n",
    "        return number\n",
    "    \n",
    "    return inner_factorial(number)\n",
    "\n",
    "                 ###################################################################################\n",
    "factorial(17)    # Good approach, can you image how does code working on your problem?? step by step\n",
    "#factorial('hello')\n",
    "#factorial(-7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "82a885b9-1603-43bd-ac4d-92840e7f7d77",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 3167 Wi-Fi hotspots in NYC.\n",
      "LinkNYC - Citybridge has the most with 1731.\n"
     ]
    }
   ],
   "source": [
    "# ***************************************************************************************************************** #\n",
    "# hotspots.py\n",
    "\n",
    "import csv\n",
    "from collections import Counter\n",
    "\n",
    "def process_hotspots(file):\n",
    "    def most_common_provider(file_obj):\n",
    "        hotspots = []\n",
    "        with file_obj as csv_file:      # <= Context manager\n",
    "            content = csv.DictReader(csv_file)\n",
    "            \n",
    "            for row in content:\n",
    "                hotspots.append(row[\"Provider\"])    # <= row['Provider'] picking dict \n",
    "                \n",
    "        counter = Counter(hotspots)\n",
    "        print(f\"There are {len(hotspots)} Wi-Fi hotspots in NYC.\\n\"\n",
    "              f\"{counter.most_common(1)[0][0]} has the most with \"\n",
    "              f\"{counter.most_common(1)[0][1]}.\")\n",
    "        \n",
    "    if isinstance(file, str):\n",
    "        file_obj = open(file, \"r\")\n",
    "        most_common_provider(file_obj)\n",
    "    else:\n",
    "        most_common_provider(file)\n",
    "\n",
    "\n",
    "#process_hotspots(\"NYC_Wi-Fi_Hotspot_Locations.csv\")   # <= file path as input of function\n",
    "\n",
    "file_obj = open(\"./NYC_Wi-Fi_Hotspot_Locations.csv\", \"r\")\n",
    "process_hotspots(file_obj)                            # <= file object as input of function\n",
    "\n",
    "del csv, Counter, process_hotspots, file_obj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b536f735-74ef-4e26-976a-e001a3a1f433",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Counter({'o': 9, 'u': 6, 'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1})]\n",
      "Help on function most_common in module collections:\n",
      "\n",
      "most_common(self, n=None)\n",
      "    List the n most common elements and their counts from the most\n",
      "    common to the least.  If n is None, then list all element counts.\n",
      "    \n",
      "    >>> Counter('abracadabra').most_common(3)\n",
      "    [('a', 5), ('b', 2), ('r', 2)]\n",
      "\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "# ****************************************************************************************** #\n",
    "###  counter.most_common([n])\n",
    "\n",
    "    # Return a list of the n most common elements and their counts from the most common to \n",
    "    # the least. If n is omitted or None, most_common() returns all elements in the counter. \n",
    "    # Elements with equal counts are ordered in the order first encountered:\n",
    "    \n",
    "from collections import Counter\n",
    "\n",
    "print([Counter('auuuuuuboooooooooracadabra')])\n",
    "\n",
    "Counter('abracadabra').most_common(3)\n",
    "print(help(Counter.most_common))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d3da858-11ef-44dd-8a35-2e17894e9dcc",
   "metadata": {},
   "source": [
    "# *******************************************************************************************************************\n",
    "\n",
    "# Do you still remember first DataCamp class?  The Object-Oriented Programming in Python Course\n",
    "# Next time we go over this course, try to get all those dots connected"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "8111fd1b-62c1-406d-a994-b94593d0df4c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling Create_obj() function...\n",
      "Making Object...\n",
      "Employee created\n",
      "function end...\n",
      "Destructor called\n"
     ]
    }
   ],
   "source": [
    "class Employee:\n",
    "    \n",
    "    # Initializing \n",
    "    def __init__(self):\n",
    "        print('Employee created')\n",
    "        \n",
    "    # Calling destructor\n",
    "    def __del__(self):\n",
    "        print(\"Destructor called\")\n",
    "        \n",
    "        \n",
    "def Create_obj():\n",
    "    print('Making Object...')\n",
    "    obj = Employee()\n",
    "    print('function end...')\n",
    "    return obj\n",
    "\n",
    "print('Calling Create_obj() function...')\n",
    "obj = Create_obj()\n",
    "#print('Program End...')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "eb95f3bb-85a5-4951-ab0a-c143706dd4e4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function iter in module builtins:\n",
      "\n",
      "iter(...)\n",
      "    iter(iterable) -> iterator\n",
      "    iter(callable, sentinel) -> iterator\n",
      "    \n",
      "    Get an iterator from an object.  In the first form, the argument must\n",
      "    supply its own iterator, or be a sequence.\n",
      "    In the second form, the callable is called until it returns the sentinel.\n",
      "\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "print(help(iter))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "id": "51bf73d1-565b-4310-91e9-16aa0fb7611d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "banana\n",
      "cherry\n",
      "<tuple_iterator object at 0x7fb308094b50>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mType:\u001b[0m        tuple_iterator\n",
       "\u001b[0;31mString form:\u001b[0m <tuple_iterator object at 0x7fb308094b50>\n",
       "\u001b[0;31mDocstring:\u001b[0m   <no docstring>\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mytuple = (\"apple\", \"banana\", \"cherry\")\n",
    "myit = iter(mytuple)\n",
    "\n",
    "print(next(myit))\n",
    "print(next(myit))\n",
    "print(next(myit))\n",
    "\n",
    "print(myit)\n",
    "\n",
    "myit\n",
    "\n",
    "?myit"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6c45677-18e8-4782-8f2c-b83e7c0895e3",
   "metadata": {},
   "source": [
    "## Building a command line data app\n",
    "\n",
    "You are building a command line tool that lets a user interactively explore a data set. We've defined four functions: mean(), std(), minimum(), and maximum() that users can call to analyze their data. Help finish this section of the code so that your users can call any of these functions by typing the function name at the input prompt.\n",
    "\n",
    "Note: The function get_user_input() in this exercise is a mock version of asking the user to enter a command. It randomly returns one of the four function names. In real life, you would ask for input and wait until the user entered a value.\n",
    "Instructions\n",
    "100 XP\n",
    "\n",
    "    Add the functions std(), minimum(), and maximum() to the function_map dictionary, like we did with mean().\n",
    "    The name of the function the user wants to call is stored in func_name. Use the dictionary of functions, function_map, to call the chosen function and pass data as an argument.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "a5a414c9-9a2f-40d5-ba5c-23f43cbacc51",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'mean' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_11087/2464581158.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Add the missing function references to the function map\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m function_map = {\n\u001b[0;32m----> 3\u001b[0;31m   \u001b[0;34m'mean'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mmean\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m   \u001b[0;34m'std'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstd\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m   \u001b[0;34m'minimum'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mminimum\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'mean' is not defined"
     ]
    }
   ],
   "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",
    "data = [1,2,3,4,5,6,7,8,9,10]\n",
    "mean(data)\n",
    "\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": "code",
   "execution_count": 6,
   "id": "40ca8790-3e14-456c-a012-75a4875df9e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5.5"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Add the missing function references to the function map\n",
    "import numpy as np\n",
    "\n",
    "function_map = {'mean': np.mean,\n",
    "                'std': np.std,\n",
    "                'minimum': np.minimum,\n",
    "                'maximum': np.maximum}\n",
    "\n",
    "#data = load_data()\n",
    "data = [1,2,3,4,5,6,7,8,9,10]\n",
    "np.mean(data)\n",
    "\n",
    "print(data)\n",
    "\n",
    "# Call the chosen function and pass \"data\" as an argument\n",
    "function_map['mean'](data)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69e1c1ba-f09d-48fe-8a95-dca76d89aa31",
   "metadata": {},
   "source": [
    "## Reviewing your co-worker's code\n",
    "\n",
    "Your co-worker is asking you to review some code that they've written and give them some tips on how to get it ready for production. You know that having a docstring is considered best practice for maintainable, reusable functions, so as a sanity check you decide to run this has_docstring() function on all of their functions.\n",
    "\n",
    "def has_docstring(func):\n",
    "  \"\"\"Check to see if the function \n",
    "  `func` has a docstring.\n",
    "\n",
    "  Args:\n",
    "    func (callable): A function.\n",
    "\n",
    "  Returns:\n",
    "    bool\n",
    "  \"\"\"\n",
    "  return func.__doc__ is not None\n",
    "\n",
    "Instructions 1/3\n",
    "35 XP\n",
    "\n",
    "    Question 1\n",
    "    Call has_docstring() on your co-worker's load_and_plot_data() function.\n",
    "    \n",
    "    \n",
    "    \n",
    "    Question 2   Seems no difference\n",
    "    Check if the function as_2D() has a docstring.\n",
    "    \n",
    "    \n",
    "    \n",
    "    Question 3\n",
    "    Check if the function log_product() has a docstring.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "25d4ea28-bc1c-4398-9044-c03068280be4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "load_and_plot_data() looks ok\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'as_2D' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_19051/3317017206.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     33\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     34\u001b[0m \u001b[0;31m# Call has_docstring() on the as_2D() function\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 35\u001b[0;31m \u001b[0mok\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhas_docstring\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mas_2D\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     36\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     37\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mok\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'as_2D' is not defined"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "def load_and_plot(path):\n",
    "    '''Load a data set and plot the first two principal components\n",
    "    Args:\n",
    "      path (str): The location of csv file\n",
    "    Returns:\n",
    "      Tuple of numpy ndarray: (features, labels)\n",
    "    '''\n",
    "    \n",
    "    data = pd.read_csv(path)      # ************************************************\n",
    "    Y = data['labels'].values     # Pandas Series add .values get NumPy array\n",
    "    X = data[[i for i in list(data.columns) if i != 'labels']].values\n",
    "    \n",
    "    return X, Y\n",
    "\n",
    "\n",
    "train_X, train_y = load_and_plot('abc.csv')\n",
    "\n",
    "\n",
    "# Call has_docstring() on the load_and_plot_data() function\n",
    "ok = has_docstring(load_and_plot)\n",
    "\n",
    "if not ok:   # Can we write Python code this way? So function runs will return Ture? \n",
    "    print(\"load_and_plot_data() doesn't have a docstring!\")\n",
    "else:\n",
    "    print(\"load_and_plot_data() looks ok\")\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# 2)Check if the function as_2D() has a docstring.\n",
    "\n",
    "# Call has_docstring() on the as_2D() function\n",
    "ok = has_docstring(as_2D)\n",
    "\n",
    "if not ok:\n",
    "    print(\"as_2D() doesn't have a docstring!\")\n",
    "else:\n",
    "    print(\"as_2D() looks ok\")\n",
    "\n",
    "\n",
    "# 3) Check if the function log_product() has a docstring.\n",
    "\n",
    "# Call has_docstring() on the log_product() function\n",
    "ok = has_docstring(log_product)\n",
    "\n",
    "if not ok:\n",
    "    print(\"log_product() doesn't have a docstring!\")\n",
    "else:\n",
    "    print(\"log_product() looks ok\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d647ea57-4890-4af4-8907-64a1ed7d43cd",
   "metadata": {},
   "source": [
    "## Returning functions for a math game\n",
    "\n",
    "You are building an educational math game where the player enters a math term, and your program returns a function that matches that term. For instance, if the user types \"add\", your program returns a function that adds two numbers. So far you've only implemented the \"add\" function. Now you want to include a \"subtract\" function.\n",
    "Instructions\n",
    "100 XP\n",
    "\n",
    "    Define the subtract() function. It should take two arguments and return the first argument minus the second argument.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "32f9a05d-8afe-40fd-a56b-c831eb629c39",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 + 2 = 7\n",
      "5 - 2 = 3\n"
     ]
    }
   ],
   "source": [
    "from numpy import subtract\n",
    "\n",
    "# Read the code and think how they put things together, nested functions and others\n",
    "def create_math_function(func_name):\n",
    "    if func_name == 'add':\n",
    "        def add(a, b):\n",
    "            return a + b    #####################################################################################\n",
    "        return add          # Think when outer function returns a inner function call, and when return inner func\n",
    "    \n",
    "    elif func_name == 'subtract':\n",
    "        # Define the subtract() function\n",
    "        def subtract(a, b):\n",
    "            return a - b\n",
    "        return subtract\n",
    "    \n",
    "    else:\n",
    "        print(\"I don't know that one\")\n",
    "    \n",
    "    \n",
    "add = create_math_function('add')   # Outer func calling add returns inner add func, then calling add(5, 2)\n",
    "print('5 + 2 = {}'.format(add(5, 2)))\n",
    "\n",
    "subtract = create_math_function('subtract')\n",
    "#print('5 - 2 = {}'.format(subtract(5, 2)))\n",
    "\n",
    "print(f'5 - 2 = {subtract(5, 2)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac9c2d4d-bbb1-4cbc-8a76-4230bb0366e3",
   "metadata": {},
   "source": [
    "## Scope\n",
    "\n",
    "\n",
    "Before we can dig into decorators, we must understandow scope works in Python.  Scope determines which variable can be accessed at different points in your code.  Variable names are very useful things, both in Python code and in the real world.  \n",
    "\n",
    "\n",
    "Python has to have strict rules aout which variable you are referring to when using a particualr variable name.  When we typed print(x) in the function foo, the interpreter had to follow those rules to determine which x we meant.  \n",
    "\n",
    "First the interpreter looks in the local scope. (when you are inside a function, the local scope is made up of the arguments and any variables defined inside the function.  This is called nonlocal scope) \n",
    "\n",
    "(in the case of nested functions, where one function is defined inside another function, Python will check the scope of parent function before checking the global scope)\n",
    "\n",
    "If the interpreter cant find the variable in the local scope, it expands its search to the global scope, these are the things defined outside the function.  \n",
    "\n",
    "Finally, if it cant find the things it is looking for in the global scope, the interpreter checks the built-in scope, these are tings that are always available in Python.  (such as print function, mean function etc.)\n",
    "\n",
    "\n",
    "**local scope:**\n",
    "      the inside of your function, any arguments or variables\n",
    "\n",
    "**Nonlocal scope**\n",
    "      in the case of nested functions, this is the scope of parent function\n",
    "\n",
    "**global scope:**\n",
    "      the things defined outside your function, \n",
    "\n",
    "**build-in scope:**\n",
    "      always in Python, for instance the print() function is in build-in scope\n",
    "\n",
    "\n",
    "# Note that Python only gives you read access to variables defined outside of your current scope.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "4a63a419-7b38-47d1-83a2-432d21873ce2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "x = 7\n",
    "\n",
    "def foo():\n",
    "    x = 42\n",
    "    print(x)\n",
    "    \n",
    "    \n",
    "foo()\n",
    "           ###########################################################################################\n",
    "print(x)   # You see we cant access back in the function\n",
    "           # Python only gives you read access to variables defined outside of your current scope"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "a6ed7043-5dca-4bb9-93ac-978d2c57ef0d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 7\n",
    "\n",
    "def foo():      ########################################################################\n",
    "    global x    # global keyword to declare the global scope variable\n",
    "                # same situation can be applied to nonlocal scope with nonlocal keyword\n",
    "    x = 42\n",
    "    print(x)\n",
    "    \n",
    "    \n",
    "foo()\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc938587-46fe-494c-9fe6-9dd635b0227d",
   "metadata": {},
   "source": [
    "# ******************************************************************************************************************\n",
    "# However, you should try to avoid using global scope variables like this if possible, because it can make testing and debugging harder.  And if we ever want to modify a variable that is defined in the nonlocal scope, we use nonlocal keyword.  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4eebb26-7160-4d0e-bf06-96ad7dda881d",
   "metadata": {},
   "source": [
    "## Understanding scope\n",
    "\n",
    "What four values does this script print?\n",
    "\n",
    "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)\n",
    "\n",
    "Answer the question\n",
    "50XP\n",
    "Possible Answers\n",
    "\n",
    "    1    50, 30, 100, 50\n",
    "\n",
    "    2    10, 30, 30, 30\n",
    "\n",
    "    3    50, 30, 100, 30\n",
    "\n",
    "    4    10, 30, 100, 50\n",
    "\n",
    "    5    50, 50, 50, 50\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "74a9fda5-3b74-49ce-b7df-0c52808f45e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50\n",
      "30\n",
      "100\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "x = 50\n",
    "\n",
    "def one():\n",
    "    x = 10    # no print()\n",
    "\n",
    "def two():\n",
    "    global x\n",
    "    x = 30    # no print()\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",
   "id": "5dfe9043-6d75-4ed4-befc-df0af4ac2252",
   "metadata": {},
   "source": [
    "## Modifying variables outside local scope\n",
    "\n",
    "Sometimes your functions will need to modify a variable that is outside of the local scope of that function. While it's generally not best practice to do so, it's still good to know how in case you need to do it. Update these functions so they can modify variables that would usually be outside of their scope.\n",
    "Instructions 1/3\n",
    "35 XP\n",
    "\n",
    "    Question 1\n",
    "    Add a keyword that lets us update call_count from inside the function.\n",
    "    \n",
    "    \n",
    "    \n",
    "    Question 2\n",
    "    Add a keyword that lets us modify file_contents from inside save_contents().\n",
    "    \n",
    "    \n",
    "    \n",
    "    Question 3\n",
    "    Add a keyword to done in check_is_done() so that wait_until_done() eventually stops looping.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "f69d51bb-32d9-41d4-b5a4-1b2d79f86b4e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You've called my_function() 1 times!\n",
      "You've called my_function() 2 times!\n",
      "You've called my_function() 3 times!\n",
      "You've called my_function() 4 times!\n",
      "You've called my_function() 5 times!\n",
      "Work done? False\n"
     ]
    }
   ],
   "source": [
    "call_count = 0\n",
    "\n",
    "def my_function():\n",
    "    # Use a keyword that lets us update call_count \n",
    "    global call_count\n",
    "    call_count += 1\n",
    "    \n",
    "    print(\"You've called my_function() {} times!\".format(\n",
    "      call_count\n",
    "    ))\n",
    "\n",
    "for _ in range(5):    # I mised i, why _ in range(20) works as well? interesting\n",
    "    my_function()\n",
    "    \n",
    "    \n",
    "    \n",
    "# 2)Add a keyword that lets us modify file_contents from inside save_contents().\n",
    "def read_files():\n",
    "    file_contents = None\n",
    "    \n",
    "    def save_contents(filename):\n",
    "        # Add a keyword that lets us modify file_contents\n",
    "        nonlocal file_contents\n",
    "        if file_contents is None:\n",
    "            file_contents = []\n",
    "        with open(filename) as fin:\n",
    "            file_contents.append(fin.read())\n",
    "            \n",
    "        for filename in ['1984.txt', 'MobyDick.txt', 'CatsEye.txt']:\n",
    "            save_contents(filename)\n",
    "    \n",
    "        return file_contents\n",
    "\n",
    "    \n",
    "    print('\\n'.join(read_files()))\n",
    "\n",
    "\n",
    "# 3)Add a keyword to done in check_is_done() so that wait_until_done() eventually stops looping.\n",
    "def wait_until_done():\n",
    "    def check_is_done():\n",
    "        # Add a keyword so that wait_until_done() \n",
    "        # doesn't run forever\n",
    "        global done\n",
    "        if random.random() < 0.1:\n",
    "            done = True\n",
    "            \n",
    "        while not done:\n",
    "            check_is_done()\n",
    "    \n",
    "done = False\n",
    "wait_until_done()\n",
    "\n",
    "print('Work done? {}'.format(done))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "353c40a4-957d-4016-87d1-f19b33bc6ad5",
   "metadata": {},
   "source": [
    "## Closures\n",
    "\n",
    "\n",
    "**The last topic I need to explain before discussing decoraotrs is how closures work in Python.  \n",
    "A closure in Python is a tuple of variables that are no longer in scope, but that a function needs in order to run.  Explain this with an example: \n",
    "\n",
    "The function foo() defines a nested function bar() that prints the value of a.  Foo returns this nested function, so when we say func = foo(), we are assigning the bar function to the variable func.  Now what happens when we call func().  As expected, it prints the value of variable a, which is 5.  \n",
    "\n",
    "**But how does function func knowing anything about a?  a is defined in foo()'s scope (the nonlocal scope) not bar()'s.  You might think that variable a is not observable outside of the scope of foo().  \n",
    "# That's where closures come it.  When foo() returns the bar() function, Python helpfully attached any nonlocal variable that bar() was going to need to the function object.  Those variables get stored in a tuple in the __closure__ attribute of the function (refering func here).  \n",
    "The closure for func has 1 variable, and you can view the value of that variable by ccessing the cell_contents of the item.  \n",
    "\n",
    "\n",
    "# *******************************************************************************************************************\n",
    "def foo():\n",
    "    a = 5\n",
    "    def bar():\n",
    "        print(a)\n",
    "    return bar\n",
    "\n",
    "func = foo()\n",
    "func()\n",
    "\n",
    "\n",
    "Lets examine this bit of code, here x is defined in the global scope, foo() creates a function bar() that prints whatever argument was passed to foo() function.  When we call foo(x) and assign the result to my_func, we pass in x.  So as expected, calling my_func() prints the value of x.  Now lets delete x and call my_func() again.  What do you think will happen this time?  \n",
    "# *******************************************************************************************************************\n",
    "# *******************************************************************************************************************\n",
    "# Thats because foo()'s value arguments gets added to the closure attached to the new my_func function.  So even though x doesnt exist anymore, the value persists in its closure.  Noticethat nothing changes if we overwrite x instead of deleting it.  \n",
    "\n",
    "\n",
    "x = 25\n",
    "def foo(value):\n",
    "    def bar():\n",
    "        print(value)\n",
    "    return bar\n",
    "\n",
    "\n",
    "my_func = foo(x)\n",
    "my_func()\n",
    "\n",
    "del x\n",
    "my_func()\n",
    "\n",
    "\n",
    "**Here we've passed x into foo() function and then assigned the foo() function to the variable x.  The old value of x 25 is still stored in the foo() function's closure, even though the foo() function is stored in the x variable.  This is going to be important to remember  when we talk about decorators in the nest lesson.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "e172eb82-73b6-47f9-b9e6-f3166593716a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "5\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "def foo():\n",
    "    a = 5\n",
    "    def bar():\n",
    "        print(a)\n",
    "    return bar\n",
    "\n",
    "\n",
    "# ***************************************************************************************************************** #\n",
    "print(len(foo().__closure__))\n",
    "print(foo().__closure__[0].cell_contents)\n",
    "\n",
    "func = foo()\n",
    "print(func.__closure__[0].cell_contents)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da21b0a8-a376-4c61-9511-ab5df666864d",
   "metadata": {},
   "source": [
    "# Let go over some of the key concepts again to be sure you understand \n",
    "\n",
    "**A nested function is a function defined inside another function, sometimes refer to the outer function as the parent and the nested function as the child.  \n",
    "**A nonlocal variable is any variable that gets defined in the parent function's scope, and that gets used by the child function.  \n",
    "**And finally, a closure is Python's way of attaching nonlocal variables to a returned function so that the function can operate even when it is called outside of its parents scope.  \n",
    "\n",
    "\n",
    "We've gone pretty deep into the internals of how Python works, and you must be wondering, why does all of this mater.  We'll finally get to learn about decorators, in order to work, decorators have to make use of all of these concepts: functions as objects, nested functions, nonlocal scope, and closures.  \n",
    "Now that you have a firm fundation to buildon, understanding how decorators work should be easy.  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4efe060b-307d-4837-8d35-299f5883f12a",
   "metadata": {},
   "source": [
    "Checking for closure\n",
    "\n",
    "You're teaching your niece how to program in Python, and she is working on returning nested functions. She thinks she has written the code correctly, \n",
    "# but she is worried that the returned function won't have the necessary information when called. Show her that all of the nonlocal variables she needs are in the new function's closure.\n",
    "Instructions 1/3\n",
    "35 XP\n",
    "\n",
    "    1 Question \n",
    "    Use an attribute of the my_func() function to show that it has a closure that is not None.\n",
    "    \n",
    "    \n",
    "    \n",
    "    2 Question\n",
    "    Show that there are two variables in the closure.\n",
    "    \n",
    "    \n",
    "    \n",
    "    3 Question\n",
    "    Get the values of the variables in the closure so you can show that they are equal to [2, 17], the arguments passed to return_a_func().\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "3efb8ea0-299d-4224-a235-3b4e4de8bc04",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "[2, 17]\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "def return_a_func(arg1, arg2):\n",
    "    def new_func():\n",
    "        print('arg1 was {}'.format(arg1))\n",
    "        print('arg2 was {}'.format(arg2))\n",
    "    return new_func\n",
    "    \n",
    "    \n",
    "    \n",
    "my_func = return_a_func(2, 17)\n",
    "\n",
    "\n",
    "# Show that my_func()'s closure is not None\n",
    "print(my_func.__closure__ is not None)\n",
    "\n",
    "\n",
    "# ***************************************************************************************************************** #\n",
    "# ***************************************************************************************************************** #\n",
    "print([i.cell_contents for i in my_func.__closure__])\n",
    "print(len(my_func.__closure__))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e875f6a5-2001-4299-a6e0-3e8f23d7a61c",
   "metadata": {},
   "source": [
    "## Closures keep your values safe\n",
    "\n",
    "You are still helping your niece understand closures. You have written the function get_new_func() that returns a nested function. The nested function call_func() calls whatever function was passed to get_new_func(). You've also written my_special_function() which simply prints a message that states that you are executing my_special_function().\n",
    "\n",
    "You want to show your niece that no matter what you do to my_special_function() after passing it to get_new_func(), the new function still mimics the behavior of the original my_special_function() because it is in the new function's closure.\n",
    "Instructions 1/3\n",
    "35 XP\n",
    "\n",
    "    Question 1\n",
    "    Show that you still get the original message even if you redefine my_special_function() to only print \"hello\".\n",
    "    \n",
    "    \n",
    "    \n",
    "    Question 2\n",
    "#    Show that even if you delete my_special_function(), you can still call new_func() without any problems.\n",
    "    \n",
    "    \n",
    "    \n",
    "    Question 3\n",
    "#    Show that you still get the original message even if you overwrite my_special_function() with the new function.\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "c06db6db-000a-4732-81c1-612748172178",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are running my_special_function()\n",
      "1\n",
      "<function my_special_function at 0x7f25529e3e50>\n"
     ]
    }
   ],
   "source": [
    "def my_special_function():\n",
    "    print('You are running my_special_function()')\n",
    "\n",
    "def get_new_func(func):\n",
    "    def call_func():\n",
    "        func()\n",
    "    return call_func\n",
    "\n",
    "new_func = get_new_func(my_special_function)\n",
    "\n",
    "\n",
    "del my_special_function\n",
    "\n",
    "\n",
    "\n",
    "# Redefine my_special_function() to just print \"hello\"\n",
    "def my_special_function():\n",
    "    print(\"hello\")\n",
    "\n",
    "\n",
    "new_func()\n",
    "print(len(new_func.__closure__))\n",
    "#print(dir(new_func.__closure__[0]))\n",
    "print(new_func.__closure__[0].cell_contents)   # Why this doent work as expected, its a function as arg passed to it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "898f04c3-c4ea-4eee-afd9-96f01ed2a6b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function create_adder.<locals>.adder at 0x7f25529e3c10>\n",
      "25\n",
      "[15]\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'int' object has no attribute '__closure__'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_2565/847624388.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     22\u001b[0m \u001b[0mpp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0madd_15\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m12\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     23\u001b[0m \u001b[0;31m#print([cell.cell_contents for cell in add_15(12).__closure__])   ###################################################\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 24\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcell\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcell_contents\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mcell\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mpp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__closure__\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m    \u001b[0;31m# THINK, Think, think.  __closure__ belongs to the parent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     25\u001b[0m \u001b[0;31m#####################################################################################################################\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     26\u001b[0m \u001b[0;31m#####################################################################################################################\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'int' object has no attribute '__closure__'"
     ]
    }
   ],
   "source": [
    "# Python program to illustrate functions\n",
    "# Functions can return another function\n",
    " \n",
    "def create_adder(x):\n",
    "    def adder(y):\n",
    "        return x+y\n",
    "    return adder\n",
    "\n",
    "\n",
    "add_15 = create_adder(15)\n",
    "print(add_15)       # outer function called, but returns a inner function, not inner function calling\n",
    "\n",
    "#####################################################################################################################\n",
    "print(add_15(10))   # when outer function was called, it returns the inner fucntion, thus 'add_15 = adder' function\n",
    "                    # and when we pass arg 10 to it ()the inner function calling as arg\n",
    "\n",
    "\n",
    "#print([cell.cell_contents for cell in my_func.__closure__])\n",
    "print([cell.cell_contents for cell in add_15.__closure__])   # cause add_15 is still a function: adder\n",
    "\n",
    "\n",
    "pp = add_15(12)\n",
    "#print([cell.cell_contents for cell in add_15(12).__closure__])   ###################################################\n",
    "print([cell.cell_contents for cell in pp.__closure__])    # THINK, Think, think.  __closure__ belongs to the parent\n",
    "#####################################################################################################################\n",
    "#####################################################################################################################"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d18e122f-fbd9-482c-8c90-f552414dcd2e",
   "metadata": {},
   "source": [
    "## Decorators\n",
    "\n",
    "\n",
    "Now that you know functions can be passed around as variables, and you understand scope and closures, we can talk about decorators.  What is a decorator?  Lets say we have a function that takes some inputs and returns some outputs. \n",
    "# A decorator is a wrapper that you can place around a function that changes that function's behavior.  You can modify the inputs, modify the outputs, or even change the behavior of the function itself.  \n",
    "\n",
    "**You may have seen decorators in Python before.  When you use them, you type the @ symbol followed by the decorator's name on the line directly above the function you are decorating.  \n",
    "\n",
    "\n",
    "It might seems kind of magical that we can alter the behavior of a function, so lets peel back the layers and see how it works.  \n",
    "\n",
    "\n",
    "# A decorator are just functions that take a function as an argument and return a modified version of that function.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7d87577-b2c7-405e-9d49-f67e6643a64f",
   "metadata": {},
   "source": [
    "**To start of, lets not have double_arg modify anything, it just takes a function and immediately returns it.  If we call this version of double_arg() function that does nothing and pass it the multiply() function and then assign the result to the variable new_multiply, then we call new_multiply(1,5) and get the same result as we would have gotten from multiply(1,5) function calling.  \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "90058537-3de6-4d7c-a29f-dc167ecb430c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def double_arg(func):\n",
    "    return func\n",
    "\n",
    "def multiply(a, b):\n",
    "    return a*b\n",
    "\n",
    "\n",
    "new_multiply = double_arg(multiply)\n",
    "\n",
    "new_multiply(3,4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57ef6b4e-4f5b-4e01-87ae-9d595375ba50",
   "metadata": {},
   "source": [
    "**In order for your decorator to return a modified function, its is usually helpful for it to define a new function to return (cause we cant simply modify it as return 2xfunc or func+func).  We'll call that nested function - wrapper()\n",
    "\n",
    "\n",
    "# *******************************************************************************************************************\n",
    "# All wrapper() does is take two arguments and passes them on to whatever function was passed to double_args() in the first place.  If double_args() then returns the new wrapper() function, the return value acts exactly the same as whatever function was passed to double_args(), assuming that the function passed to double_args() also takes exactly two arguments.  So double_arg() is still not doing anything to actually modify the function it is decorating.  \n",
    "\n",
    "# *******************************************************************************************************************\n",
    "# Once again, we'll pass multiply() function to double_args() function and assign the result to new_multiply variable (or say the new_multiply() function).  If we then call new_multiply(), which is now equal to the wrapper() function, (cause when double_arg() function is called with multiply() function as argument, it returns the wrapper function) wrapper() calls the decorated multiply() function cause it passed to double_args() function as arg (__closure__).  So this equivalent wrapper() function calls decorated multiply() function with modified new args, returns what we want. \n",
    "\n",
    "# *******************************************************************************************************************\n",
    "# Now lets actually modify the function our decorator is decorating.  \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "aabed5e6-f851-443e-be3c-5f4d5e5cfd93",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "new_multiply(3,7): 84\n",
      "new_add(3,7): 20\n",
      "new_add(3,7) 40\n"
     ]
    }
   ],
   "source": [
    "def multiply(a, b):\n",
    "    return a*b\n",
    "\n",
    "def double_arg(func):                         #####################################################################\n",
    "    # define new function that we can modify  # Cause we want to modify the args of func we are going to decorate\n",
    "    def wrapper(a, b):\n",
    "        a_new, b_new = a*2, b*2\n",
    "        return func(a_new, b_new)\n",
    "        #return func(a/2, b/2)\n",
    "    # return the new function        # the enclosing function do not return the nested function call, \n",
    "    return wrapper                   # when using @decrator, the enclosing function returns nested function \n",
    "                                     ###########################################################################\n",
    "new_multiply = double_arg(multiply)  # Passing multiply() to double_arg() and assign result to new_multiply variable\n",
    "print('new_multiply(3,7):', new_multiply(3, 7))  # Then calling new_multiple(3,7) which is now equal to wrapper(3,7)\n",
    "                                                 # and it calls multiply() and pass modified args and return it\n",
    "                                                 # So now the whole thing returns what we want \n",
    "\n",
    "# ***************************************************************************************************************** #\n",
    "@double_arg                     # and we can do it this way, very interesting\n",
    "def new_add(a, b):\n",
    "    return a+b\n",
    "print('new_add(3,7):', new_add(3, 7))\n",
    "\n",
    "\n",
    "new_add = double_arg(new_add)\n",
    "print('new_add(3,7)', new_add(3, 7))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7296505-5ce7-44ae-b420-4bf8b2141b8a",
   "metadata": {},
   "source": [
    "# This time, instead of assigning the new function to new_multiply variable, we are going to overwrite the multiply variable.  \n",
    "\n",
    "**And remember that we can do this because Python stores the original multiply function in the new function's closure.  When I first show you the double_args() decorator at the beginning of this lecture, I used \n",
    "# @double_args on the line above the definition of multiply() function.  This is just a Python convenience for saying multiply equals the value returned by calling double_args() function with multiply() function as the only argument.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "014b76a2-668f-4653-aba7-0a4e554ceba1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "multiply(3,7): 84\n",
      "<function multiply at 0x7f25529e3a60>\n",
      "96\n"
     ]
    }
   ],
   "source": [
    "def multiply(a, b):\n",
    "    return a*b\n",
    "\n",
    "def double_arg(func):    \n",
    "    def wrapper(a, b):\n",
    "        a_new, b_new = a*2, b*2\n",
    "        return func(a_new, b_new)\n",
    "    return wrapper\n",
    "\n",
    "\n",
    "multiply = double_arg(multiply)\n",
    "print('multiply(3,7):', multiply(3, 7)) \n",
    "\n",
    "print(multiply.__closure__[0].cell_contents)\n",
    "\n",
    "op = multiply(4, 6)\n",
    "print(op)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b8d2d63-058b-4b72-95f2-9e2872011743",
   "metadata": {},
   "source": [
    "## Using decorator syntax\n",
    "\n",
    "You have written a decorator called print_args that prints out all of the arguments and their values any time a function that it is decorating gets called.\n",
    "Instructions 1/2\n",
    "50 XP\n",
    "\n",
    "    Question 1\n",
    "    Decorate my_function() with the print_args() decorator by redefining the my_function variable.\n",
    "    \n",
    "    \n",
    "    \n",
    "    Question 2\n",
    "    Decorate my_function() with the print_args() decorator using decorator syntax.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "375e452d-29ca-4f58-b0fc-f16bf16350a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my_function was called with a=1, b=2, c=3\n",
      "6\n",
      "my_function2 was called with a=2, b=2, c=3\n",
      "12\n"
     ]
    }
   ],
   "source": [
    "def my_function(a, b, c):\n",
    "    print(a+b+c)\n",
    "    \n",
    "    \n",
    "def print_args(func):\n",
    "    def wrapper(a, b, c):      # just because I know the args we are using is a,b,c, can this be universal? \n",
    "        print(f'{func.__name__} was called with a={a}, b={b}, c={c}')\n",
    "        return func(a, b, c)   # Thit one is important, the key to make decorator mechanism possible.  THINK Think\n",
    "    return wrapper             ######################################################################################\n",
    "\n",
    "\n",
    "# Decorate my_function() with the print_args() decorator ############################################################\n",
    "my_function = print_args(my_function)\n",
    "\n",
    "my_function(1, 2, 3)\n",
    "\n",
    "\n",
    "# Decorate my_function() with the print_args() decorator using decorator syntax\n",
    "@print_args\n",
    "def my_function2(a, b, c):\n",
    "    print(a*b*c)\n",
    "\n",
    "my_function2(2,2,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cde74fdd-8d07-42b5-8371-c325d5289e71",
   "metadata": {},
   "source": [
    "## Defining a decorator\n",
    "\n",
    "Your buddy has been working on a decorator that prints a \"before\" message before the decorated function is called and prints an \"after\" message after the decorated function is called. They are having trouble remembering how wrapping the decorated function is supposed to work. Help them out by finishing their print_before_and_after() decorator.\n",
    "Instructions\n",
    "100 XP\n",
    "\n",
    "    Call the function being decorated and pass it the positional arguments *args.\n",
    "    Return the new decorated function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "cf18209e-5441-4e0e-a3e8-53c9f61bad86",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before multiply\n",
      "50\n",
      "After multiply\n"
     ]
    }
   ],
   "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",
    "\n",
    "@print_before_and_after\n",
    "def multiply(a, b):\n",
    "    print(a * b)\n",
    "\n",
    "    \n",
    "multiply(5, 10)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c577b996-b19d-44c6-985e-78f6c95c7a56",
   "metadata": {},
   "source": [
    "## Real-world examples\n",
    "\n",
    "\n",
    "**You've learned a lot about how decorators work.  This lesson will walk you through some real-world decorators so that you can start to recognize common patterns.  The timer() decorator runs the decorated function and then prints how long it took for the function to run \n",
    "# (for this purpost, %timeit and line_profiler can do it better).  \n",
    "I usually wind up adding some version \n",
    "# (need to reach out on this topic, can we combine %timeit and line_profiler) \n",
    "of this to all of my projects because it is a pretty easy way to figure out where your computational bottlenecks are.  \n",
    "\n",
    "**All decorator have fairly similar-looking docstrings because they all take and return a single function, for brevity, I will only include the description of the function in the dosctring of the examples that follow.  \n",
    "\n",
    "\n",
    "# *******************************************************************************************************************\n",
    "**Like most decorators, we'll start off by defining a wrapper() function.  This is the function that the decorator will return.  The wrapper() function takes any number of positional and keyword arguments so that it can be used to decorate any function.  The first thing the new function will do is record the time that it was called with the time() function.  Then wrapper() function gets the result of calling the decorated function, and we dont return that value yet though.  After calling the decorated function, wrapper() checks the time again, and prints a message about how long it took to run the decorated function.  Once we've done that, we need to return the result that the decorated function returned before.  \n",
    "\n",
    "\n",
    "So if we decorate this simple sleep_n_seconds() function, you can see that sleeping for 21 seconds takes about 21 seconds (not %timeit).  This is a trivial use of the decorator to show how it works, but can be very useful for finding the slow parts of your code.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "0abae419-1023-4538-9790-b3ca1705aaca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sleep_n_seconds tooks 21.03239107131958 to run\n",
      "hi\n",
      "hi tooks 0.00015926361083984375 to run\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "def timer(func):\n",
    "    \"\"\"A decorator that prints how long a function tooks to run\n",
    "    \"\"\"\n",
    "    \n",
    "    def wrapper(*args, **kwargs):\n",
    "        start = time.time()              # when wrapper was called, first check the current time\n",
    "        result = func(*args, **kwargs)   # call the decorated function and store the result for later return\n",
    "        t_spend = time.time() - start    # Cause if returned, function finished running\n",
    "        print(f'{func.__name__} tooks {t_spend} to run')\n",
    "        return result                    # return the result that the decorated function returned before\n",
    "    return wrapper\n",
    "\n",
    "\n",
    "@timer\n",
    "def hi():\n",
    "    print('hi')\n",
    "    \n",
    "@timer\n",
    "def sleep_n_seconds(n):\n",
    "    time.sleep(n)\n",
    "    \n",
    "sleep_n_seconds(21)\n",
    "hi()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "190e260c-a6f5-4b7b-9545-2a56377fb2ef",
   "metadata": {},
   "source": [
    "# *******************************************************************************************************************\n",
    "# *******************************************************************************************************************\n",
    "**Memorizing is the process of storing the results of a function so that the next time the function is called with the same arguments, you can just look up the answer. \n",
    "\n",
    "\n",
    "# *******************************************************************************************************************\n",
    "# *******************************************************************************************************************\n",
    "**We startby setting up a dictionary that will map arguments to results.  Then as usual, we craete wrapper() to be the new decorated function that this decorator returns.  When the new function gets called, we check to see wheather we've ever seen these arguments before.  If we havent, we send them to the decorated function and store the result in the cache dictionary.  Now we can look up the return value quickly in a dictionaryof results.  The next timewe call this function with those same arguments, the return value will already be in the dictionary.  In below code example, we are memorizing (decorate) the simple_add() function.  \n",
    "\n",
    "\n",
    "\n",
    "# *******************************************************************************************************************\n",
    "# So when is it appropriate to use a decorator?  You should consider using a decorator when you want to add some common bit of code to multiple functions.  \n",
    "We could have added timing code (code blocks, do ou still remember?) in the body of all these functions, but that would violate the principle of Dont Repear Yourself, thus adding a decorator is a better choice.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "a260349f-b9ae-4179-bc99-71cf891b59e5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sleep for 3 seconds\n",
      "2090\n",
      "2090\n"
     ]
    }
   ],
   "source": [
    "def memorize(func):\n",
    "    \"\"\"Store the results of the decorated function for fast look up\n",
    "    \"\"\"\n",
    "    # Store results in a dictionary that maps arguments to results\n",
    "    cache = {}\n",
    "    # Define wrapper function to return\n",
    "    def wrapper(*args):\n",
    "        if (args) not in cache:\n",
    "            cache[(args)] = func(*args)\n",
    "        return cache[(args)]\n",
    "    return wrapper\n",
    "\n",
    "\n",
    "import time\n",
    "@memorize\n",
    "def simple_add(a, b, c):\n",
    "    print('Sleep for 3 seconds')\n",
    "    time.sleep(3)\n",
    "    return a+b+c\n",
    "\n",
    "\n",
    "print(simple_add(12,98,1980))\n",
    "                                 ####################################################################################\n",
    "print(simple_add(12,98,1980))    # Not sleeping, cause it just return cache[(args)], not even call decorated function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "ef7faba1-be33-4fcb-a40c-3e024540fd87",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "factorial tooks 2.5272369384765625e-05 to run\n",
      "138683118545689835737939019720389406345902876772687432540821294940160000000000000\n",
      "factorial tooks 4.1484832763671875e-05 to run\n",
      "31469973260387937525653122354950764088012280797258232192163168247821107200000000000000\n"
     ]
    }
   ],
   "source": [
    "@memorize\n",
    "@timer\n",
    "def factorial(number):\n",
    "    # Validate input\n",
    "    if not isinstance(number, int):\n",
    "        raise TypeError(\"Sorry. 'number' must be an integer.\")\n",
    "    if number < 0:\n",
    "        raise ValueError(\"Sorry. 'number' must be zero or positive.\")\n",
    "    \n",
    "    # Calculate the factorial of number\n",
    "    def inner_factorial(number):\n",
    "        if number <= 1:\n",
    "            return 1\n",
    "        return number * inner_factorial(number - 1)\n",
    "    return inner_factorial(number)\n",
    "\n",
    "\n",
    "\n",
    "print(factorial(59))\n",
    "print(factorial(62))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00db7eb3-5c67-4ac9-b73a-7fb5a473d370",
   "metadata": {},
   "source": [
    "## Print the return type\n",
    "\n",
    "You are debugging a package that you've been working on with your friends. Something weird is happening with the data being returned from one of your functions, but you're not even sure which function is causing the trouble. You know that sometimes bugs can sneak into your code when you are expecting a function to return one thing, and it returns something different. For instance, if you expect a function to return a numpy array, but it returns a list, you can get unexpected behavior. To ensure this is not what is causing the trouble, you decide to write a decorator, print_return_type(), that will print out the type of the variable that gets returned from every call of any function it is decorating.\n",
    "Instructions\n",
    "100 XP\n",
    "\n",
    "    Create a nested function, wrapper(), that will become the new decorated function.\n",
    "    Call the function being decorated.\n",
    "    Return the new decorated function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "6071dee3-809a-4e6f-9f77-8985493d312e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "foo() returned type <class 'int'>\n",
      "42\n",
      "foo() returned type <class 'list'>\n",
      "[1, 2, 3]\n",
      "foo() returned type <class 'dict'>\n",
      "{'a': 42}\n"
     ]
    }
   ],
   "source": [
    "def print_return_type(func):\n",
    "    # Define wrapper(), the decorated function\n",
    "    def wrapper(*args, **kwargs):\n",
    "        # Call the function being decorated\n",
    "        result = func(*args, **kwargs)    ##### Keep these stars??\n",
    "        print('{}() returned type {}'.format(func.__name__, type(result)))\n",
    "        return result\n",
    "    # Return the decorated function\n",
    "    return wrapper\n",
    "\n",
    "\n",
    "@print_return_type\n",
    "def foo(value):\n",
    "    return value\n",
    "  \n",
    "print(foo(42))\n",
    "print(foo([1, 2, 3]))\n",
    "print(foo({'a': 42}))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78c8eb5c-8503-4df3-ba59-4e3909a29006",
   "metadata": {},
   "source": [
    "## Counter\n",
    "\n",
    "# *******************************************************************************************************************\n",
    "# *******************************************************************************************************************\n",
    "# *******************************************************************************************************************\n",
    "# You're working on a new web app, and you are curious about how many times each of the functions in it gets called. So you decide to write a decorator that adds a counter to each function that you decorate. You could use this information in the future to determine whether there are sections of code that you could remove because they are no longer being used by the app.\n",
    "Instructions\n",
    "100 XP\n",
    "\n",
    "    Call the function being decorated and return the result.\n",
    "    Return the new decorated function.\n",
    "    Decorate foo() with the counter() decorator.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "f712be39-d952-4a76-b033-b7d99811b85f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "foo was called 1 times\n",
      "3\n",
      "calling foo()\n",
      "foo was called 2 times\n",
      "7\n",
      "calling foo()\n",
      "foo() was called 2 times.\n"
     ]
    }
   ],
   "source": [
    "def counter(func):\n",
    "    def wrapper(*args, **kwargs):\n",
    "        wrapper.count += 1\n",
    "        # Call the function being decorated and return the result\n",
    "        print(f'{func.__name__} was called {wrapper.count} times')\n",
    "        return func(*args, **kwargs)\n",
    "    wrapper.count = 0\n",
    "    # Return the new decorated function\n",
    "    return wrapper\n",
    "\n",
    "                                                   ##################################################################\n",
    "# Decorate foo() with the counter() decorator      ##################################################################\n",
    "@counter                                           # This is a very useful and brilliant idea\n",
    "def foo(a, b):\n",
    "    print(a+b)\n",
    "    print('calling foo()')\n",
    "\n",
    "foo(1,2)\n",
    "foo(3,4)\n",
    "\n",
    "print('foo() was called {} times.'.format(foo.count))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cde0dfe-10a6-4c3d-91d1-45f0ebb9b968",
   "metadata": {
    "tags": []
   },
   "source": [
    "# *******************************************************************************************************************\n",
    "# Check below code and trying to connect the dots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "decfe9bd-5891-404a-8bcf-03be1ae2338d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       Start: 2\n",
      "         End: 1\n",
      "testfunction: 3\n"
     ]
    }
   ],
   "source": [
    "# import inspect\n",
    "from __future__ import print_function\n",
    "\n",
    "class Counter(object):\n",
    "\t\"\"\"Simple counter, counting an invocation my means of a string (explicit call) or function name (decorator)\"\"\"\n",
    "\n",
    "\tcounters = {}\n",
    "\tdef __init__(self, *args, **kwargs):\n",
    "\t\t\"\"\"Construct class. First, check if class is called via a decorator or directly. If true, \n",
    "        defer incrementing counter until wrapped function is actually called (see __call__). If false, \n",
    "        increment counter now.\"\"\"\n",
    "\t\tif callable(args[0]):\n",
    "\t\t\tself.func = args[0]\n",
    "\t\t\tself.name = args[0].__name__\n",
    "\t\telse:\n",
    "\t\t\tname = args[0]\n",
    "\n",
    "\t\t\tself.potentiallyIncrementByName(name)\n",
    "\n",
    "\tdef __call__(self, *args, **kwargs):\n",
    "\t\t\"\"\"Function for when Counter is used as a decorator. In that case, \n",
    "        this class method call with increment the counter.\"\"\"\n",
    "\t\tself.potentiallyIncrementByName(self.name)\n",
    "\t\treturn self.func(*args, **kwargs)\n",
    "\n",
    "\t@classmethod\n",
    "\tdef potentiallyIncrementByName(self, name):\n",
    "\t\t\"\"\"Either the Counter is incremented (if it exists already) or created\"\"\"\n",
    "\t\t# frame = inspect.getframeinfo(inspect.stack()[2][0])\n",
    "\t\tif name in Counter.counters:\n",
    "\t\t\tCounter.counters[name] += 1\n",
    "\t\telse:\n",
    "\t\t\tCounter.counters[name] = 1\n",
    "\t\t# print(frame.function)\n",
    "\t\t# print(frame.lineno)\n",
    "\n",
    "\t@classmethod\n",
    "\tdef print(self):\n",
    "\t\t\"\"\"Convenience method to print counted methods.\"\"\"\n",
    "\t\tpadding = len(max(Counter.counters.keys()))\n",
    "\t\tfor (name, count) in Counter.counters.items():\n",
    "\t\t\tprint(\"{name:>{pad}}: {count}\".format(name=name, pad=padding, count=count))\n",
    "\n",
    "@Counter\n",
    "def testfunction():\n",
    "\treturn 1\n",
    "\n",
    "def example():\n",
    "\tCounter(\"Start\")\n",
    "\tCounter(\"Start\")\n",
    "\tCounter(\"End\")\n",
    "\n",
    "\ttestfunction()\n",
    "\ttestfunction()\n",
    "\ttestfunction()\n",
    "\n",
    "\tCounter.print()\n",
    "\n",
    "if __name__ == '__main__':\n",
    "\texample()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7520f293-6352-4f22-a928-7c93a7b9bc77",
   "metadata": {},
   "source": [
    "## Decorators and metadata\n",
    "\n",
    "\n",
    "\n",
    "**One of the problems with decorators is that they obscure the decorated function's metadata.  In this lesson, I'll show you why its a problem and how to fix it.  \n",
    "\n",
    "Here we have a nice function, sleep_n_seconds(), with a docstring that explains exactly what it does.  If we look at the docstring sttribute, we can see that the text of the docstring.  We can also access other metadata for the function, like its name and default arguments.  \n",
    "\n",
    "But watch what happens when we decorate sleep_n_seconds() with the timer() decorator as we're done below.  When we try to print the docstring, we get nothing back, even stranger, when we try to look up the function's name, Python tells us that sleep_n_seconds()'s name is wrapper.  \n",
    "\n",
    "# ******************************************************************************************************************\n",
    "To understand why we have to examine the timer() decorator, remember that when we write decorators, we almost always define a nested wrapper function to return.  \n",
    "# (So when we calling the decorated func or calling decorate_func(decorated func) object with decorated func's args, what actual returns is a wrapper function, but running func and its args.)\n",
    "Because the decorator overwrites the sleep_n_seconds() function, when you ask for sleep_n_seconds()'s name, docstring or any metadata, you are actually referencing the nested wrapper function that was returned by the decorator.  \n",
    "\n",
    "# Fortunately, Python provides us with an easy way to fix this.  The wraps() function from the functools module is a decorator that you can use when defining a decorator.  If you use it to decorate the wrapper function that your decorator returns, it will modify wrapper()'s metadata to look like the function you are decorating.  Notice that wraps() decorator takes the function you are decorating as an argument.  \n",
    "\n",
    "**We havent talk about decorators that takes arguments yet, but we will cover that in the next lesson.  If we use this updated version of the timer() decorator to decorate the sleep_n_seconds() and then try to print sleep_n_seconds()'s docstring, we get the result as expected.  Likewise, printing the name or any metadata of decorated function returns the desired metadata, rather than he metadata from the wrapper function.  \n",
    "\n",
    "# *******************************************************************************************************************\n",
    "As an added bonus, using wraps() when creating your decorator also gives you easy access to the original undecorated function via the __wrapped__ attribute.  Of course, you always had access to this function via the closure, but this is an easy way to get to it if you need it.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "id": "60688286-9e92-4a1d-bcd2-a82ba7cb36d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "func: factorial, spend 0.10302734375 ms time to run\n",
      "factorial\n",
      "A call-self function calculating factorial of given value\n",
      "    Args:\n",
      "      n (int): integer less than 1000\n",
      "    \n",
      "<function factorial at 0x7f25341e9dc0>\n",
      "<functools._lru_cache_wrapper object at 0x7f2534221720>\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "from functools import cache, wraps\n",
    "\n",
    "def timer(func):\n",
    "    \"\"\"A decorator that prints how long a function tooks to run\n",
    "    \"\"\"\n",
    "    @wraps(func)\n",
    "    def wrapper(*args, **kwargs):\n",
    "        start = time.time()*1000\n",
    "        results = func(*args, **kwargs)\n",
    "        t_spend = time.time()*1000 - start\n",
    "        print(f\"func: {func.__name__}, spend {t_spend} ms time to run\")\n",
    "        return results\n",
    "    return wrapper                     #(*args, **kwargs)\n",
    "\n",
    "@cache\n",
    "@timer\n",
    "def factorial(n):\n",
    "    '''A call-self function calculating factorial of given value\n",
    "    Args:\n",
    "      n (int): integer less than 1000\n",
    "    '''\n",
    "    if not isinstance(n, int):\n",
    "        raise ValueError('input n should be integer')\n",
    "    if n<=0:\n",
    "        raise ValueError('input n should be positive')\n",
    "    \n",
    "    def inner_factorial(n):\n",
    "        if n <=1:\n",
    "            return 1\n",
    "        return n*inner_factorial(n-1)\n",
    "    return inner_factorial(n)\n",
    "    \n",
    "    \n",
    "factorial(199)\n",
    "\n",
    "print(factorial.__name__)#, factorial.__defaults__)  # Cause factorial() was decorated, it actually running wrapper()\n",
    "print(factorial.__doc__)\n",
    "\n",
    "print(factorial.__wrapped__)\n",
    "print(factorial)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f3b6b45-5d76-425e-8051-d726afd77505",
   "metadata": {},
   "source": [
    "## Preserving docstrings when decorating functions\n",
    "\n",
    "Your friend has come to you with a problem. They've written some nifty decorators and added them to the functions in the open-source library they've been working on. However, they were running some tests and discovered that all of the docstrings have mysteriously disappeared from their decorated functions. Show your friend how to preserve docstrings and other metadata when writing decorators.\n",
    "Instructions 1/4\n",
    "25 XP\n",
    "\n",
    "    Question 1\n",
    "    Decorate print_sum() with the add_hello() decorator to replicate the issue that your friend saw - that the docstring disappears.\n",
    "    \n",
    "    \n",
    "    \n",
    "    Question 2\n",
    "    To show your friend that they are printing the wrapper() function's docstring, not the print_sum() docstring, add the following docstring to wrapper():\n",
    "    \"\"\"Print 'hello' and then call the decorated function.\"\"\"\n",
    "    \n",
    "    \n",
    "    \n",
    "    Question 3\n",
    "    Import a function that will allow you to add the metadata from print_sum() to the decorated version of print_sum().\n",
    "    \n",
    "    \n",
    "    \n",
    "    Question 4\n",
    "    Finally, decorate wrapper() so that the metadata from func() is preserved in the new decorated function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "575f0f37-8212-497d-9f2b-0fe0286dcf6e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "30\n",
      "Adds two numbers and prints the sum\n",
      "print_sum\n"
     ]
    }
   ],
   "source": [
    "from functools import wraps\n",
    "\n",
    "\n",
    "def add_hello(func):\n",
    "    @wraps(func)\n",
    "    def wrapper(*args, **kwargs):\n",
    "        \"\"\"Print 'hello' and then call the decorated function.\"\"\"\n",
    "        print('Hello')\n",
    "        return func(*args, **kwargs)\n",
    "    return wrapper\n",
    "\n",
    "# Decorate print_sum() with the add_hello() decorator\n",
    "@add_hello\n",
    "def print_sum(a, b):\n",
    "    \"\"\"Adds two numbers and prints the sum\"\"\"\n",
    "    print(a + b)\n",
    "\n",
    "print_sum(10, 20)\n",
    "print_sum_docstring = print_sum.__doc__\n",
    "print(print_sum_docstring)\n",
    "\n",
    "print(print_sum.__name__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6173b908-9f55-4ee2-b9f7-9b6b634edfae",
   "metadata": {},
   "source": [
    "## Measuring decorator overhead\n",
    "\n",
    "# *******************************************************************************************************************\n",
    "# Your boss wrote a decorator called check_everything() that they think is amazing, and they are insisting you use it on your function. However, you've noticed that when you use it to decorate your functions, it makes them run much slower. You need to convince your boss that the decorator is adding too much processing time to your function. To do this, you are going to measure how long the decorated function takes to run and compare it to how long the undecorated function would have taken to run. This is the decorator in question:\n",
    "\n",
    "def check_everything(func):\n",
    "  @wraps(func)\n",
    "  def wrapper(*args, **kwargs):\n",
    "    check_inputs(*args, **kwargs)\n",
    "    result = func(*args, **kwargs)\n",
    "    check_outputs(result)\n",
    "    return result\n",
    "  return wrapper\n",
    "\n",
    "Instructions\n",
    "100 XP\n",
    "\n",
    "    Call the original function instead of the decorated version by using an attribute of the function that the wraps() statement in your boss's decorator added to the decorated function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "7de6be60-0ba1-4c9e-87ec-9cb01e2a3b76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished check inputs\n",
      "finished check outputs\n",
      "Decorated time: 0.00085s\n",
      "Undecorated time: 0.00016s\n"
     ]
    }
   ],
   "source": [
    "from functools import wraps\n",
    "import time\n",
    "\n",
    "def check_inputs(my_list):\n",
    "    if not isinstance(my_list, list):\n",
    "        raise ValueError('input my_list should be a list')\n",
    "    print('finished check inputs')\n",
    "    \n",
    "def check_outputs(result):\n",
    "    if not isinstance(result, list):\n",
    "        raise ValueError('output result should be a list')\n",
    "    print('finished check outputs')\n",
    "\n",
    "        \n",
    "def check_everything(func):\n",
    "    @wraps(func)\n",
    "    def wrapper(*args, **kwargs):\n",
    "        check_inputs(*args, **kwargs)     ###########################################################################\n",
    "        result = func(*args, **kwargs)    ###########################################################################\n",
    "        check_outputs(result)             ###########################################################################\n",
    "        return result\n",
    "    return wrapper\n",
    "\n",
    "\n",
    "@check_everything\n",
    "def duplicate(my_list):\n",
    "    \"\"\"Return a new list that repeats the input twice\"\"\"\n",
    "    return my_list + my_list\n",
    "\n",
    "\n",
    "t_start = time.time()\n",
    "duplicate(list(range(5000)))\n",
    "t_end = time.time()\n",
    "decorated_time = t_end - t_start\n",
    "\n",
    "t_start = time.time()\n",
    "# Call the original function not decorated one    ###################################################################\n",
    "duplicate.__wrapped__(list(range(5000)))          # Using decorated_func.__wrapped__ gives us the original func\n",
    "# ***************************************************************************************************************** #\n",
    "# ***************************************************************************************************************** #\n",
    "t_end = time.time()\n",
    "undecorated_time = t_end - t_start\n",
    "\n",
    "print('Decorated time: {:.5f}s'.format(decorated_time))\n",
    "print('Undecorated time: {:.5f}s'.format(undecorated_time))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "58604cbd-baa2-417c-86be-b0b5c761ce3c",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "check_inputs passed\n",
      "check_outputs passed\n",
      "func: duplicate, spend 0.13330078125 ms time to run\n",
      "[1878, 552, 1333, 160, 1260, 94, 1131, 133, 1256, 333]\n"
     ]
    }
   ],
   "source": [
    "from functools import wraps, cache\n",
    "import time\n",
    "import random\n",
    "\n",
    "\n",
    "def check_inputs(my_list):\n",
    "    if not isinstance(my_list, list):\n",
    "        raise ValueError('input my_list should be a list')\n",
    "    else:\n",
    "        print('check_inputs passed')\n",
    "    \n",
    "def check_outputs(result):\n",
    "    if not isinstance(result, list):\n",
    "        raise ValueError('output result should be a list')\n",
    "    else:\n",
    "        print('check_outputs passed')\n",
    "\n",
    "def check_everything(func):\n",
    "    @wraps(func)\n",
    "    def wrapper(*args):\n",
    "        check_inputs(*args)\n",
    "        result = func(*args)\n",
    "        check_outputs(result)\n",
    "        return result\n",
    "    return wrapper\n",
    "\n",
    "def timer(func):\n",
    "    @wraps(func)\n",
    "    def wrapper(*args):\n",
    "        start = time.time()*1000\n",
    "        result = func(*args)\n",
    "        t_spend = time.time()*1000 - start\n",
    "        print(f\"func: {func.__name__}, spend {t_spend} ms time to run\")\n",
    "        return result\n",
    "    return wrapper\n",
    "\n",
    "\n",
    "@timer\n",
    "@check_everything\n",
    "def duplicate(my_list):\n",
    "    \"\"\"Return a new list that repeats the input twice\"\"\"\n",
    "    return my_list + my_list\n",
    "\n",
    "a = [random.randrange(1, 2000) for i in range(4000)]\n",
    "\n",
    "alpha = duplicate(a)\n",
    "print(alpha[:10])\n",
    "\n",
    "\n",
    "del check_inputs, check_outputs, check_everything, timer, wraps, cache, duplicate, a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "beff125d-615c-4b89-9ee5-f509fed516ab",
   "metadata": {
    "tags": []
   },
   "source": [
    "## how to write more efficient function, spend less time\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06b552b2-c7e0-4d0f-93d9-28707718e3c7",
   "metadata": {},
   "source": [
    "## Decorators that take arguments\n",
    "\n",
    "\n",
    "\n",
    "# *******************************************************************************************************************\n",
    "**Sometimes it would be nice to add arguments to our decorators.  To do that we need to add another level of function nesting.  Lets consider this silly run_three_times() decorator.  If you use it to decorate a function, it will run that function three times.  \n",
    "\n",
    "\n",
    "# *******************************************************************************************************************\n",
    "**Now lets think about what we would need to change if we wanted to write a run_n_times() decorator.  We want pass n as an argument, instead of hard-coding it in the decorator - for i in range(3), but for i in range(n).  If we had some way to pass n into the decorator, we would decorate print_sum() so that it get run 3 times and decorate print_hello() 5 times.  \n",
    "# But a decorator is only supposed to take 1 argument - the function it is decorating.  Also when you use decorator syntax, you're not supposed to use the parenthese.  \n",
    "\n",
    "\n",
    "# *******************************************************************************************************************\n",
    "**To make run_n_times() work, we have to turn it into a function that returns a decorator, rather than a function that is a decorator.  \n",
    "\n",
    "So lets start by redefining run_n_times() so that it takes n as an argument instead of func. \n",
    "Then inside of run_n_times(), we'll define a new decorator function.  This function takes func as an argument because it is the function that will be acting as our decorator.  We start ur new decorator with a nested wrapper() function as usual.  Now since we are still inside the run_n_times()function, we have the access to the n parameter that was passed to run_n_times() function.  We can use that to control hom many times we repeat the loop that calls our decorated function.  As usual for any decorator, we return the new wrapper function, and if run_n_times() returns the decorator() function we just defined, then we can use that return value as a decorator.  \n",
    "\n",
    "**Notice how when we decorate print_sum() with runn_times(), we use parentheses after @run_n_times(3) like this?  This indicates that we are actually calling run_n_times() and decorating print_sum() with the result of run_n_times(3) function call.  And since the return value from run_n_times(3) is a decorator function, we can use it to decorate print_sum() function.  \n",
    "\n",
    "This is a little bit confusing, so let me show you how this works without using decorator syntax.  Like before, we have a function run_n_times() that returns a decorator function when you call it.  If we call run_n_times() with arg 3, it will return a decorator.  We would decorate print_sum() with this new decorator using decorator syntax (@decorator_function, and this decorator_function must takes func as argument).  \n",
    "\n",
    "\n",
    "# *******************************************************************************************************************\n",
    "**Because when we use a decorator syntax, the thing after the at symbol must be a reference to a decorator function, we can use the name of a specific decorator, or we can call a function that returns a decorator.  \n",
    "\n",
    "\n",
    "# I tried to keep those examples simple to explain the concept of decorators.  In the next lesson, I'll show you some useful things you can do with decorators that takes arugments like this. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "f579289c-c7b9-4935-b428-a1833254627c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n",
      "16\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "def run_three_times(func):\n",
    "    def wrapper(*args, **kwargs):\n",
    "        for i in range(3):\n",
    "            func(*args, **kwargs)\n",
    "    return wrapper\n",
    "\n",
    "@run_three_times\n",
    "def print_sum(a, b):\n",
    "    print(a+b)\n",
    "    \n",
    "print_sum(9, 7)\n",
    "\n",
    "del run_three_times, print_sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "87b81237-3011-4880-b7ea-6bebb62adfa4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n",
      "16\n",
      "16\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "def run_n_times(n):\n",
    "    def decorator(func):\n",
    "        def wrapper(*args, **kwargs):\n",
    "            for i in range(n):\n",
    "                func(*args, **kwargs)\n",
    "        return wrapper\n",
    "    return decorator\n",
    "\n",
    "@run_n_times(4)\n",
    "def print_sum(a, b):\n",
    "    print(a+b)\n",
    "    \n",
    "    \n",
    "print_sum(9,7)\n",
    "\n",
    "del print_sum, run_n_times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "id": "26abd2f8-c0ee-4a51-bae8-a97bdb61b158",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pppp\n",
      "pppp\n",
      "pppp\n"
     ]
    }
   ],
   "source": [
    "def run_n_times(n):\n",
    "    def decorator(func):\n",
    "        def wrapper(*args, **kwargs):\n",
    "            for i in range(n):\n",
    "                func(*args, **kwargs)\n",
    "        return wrapper\n",
    "    return decorator\n",
    "\n",
    "run_3_times = run_n_times(3)   # the function that returns a decorator\n",
    "\n",
    "\n",
    "# ***************************************************************************************************************** #\n",
    "print = run_3_times(print)\n",
    "print('pppp')\n",
    "\n",
    "del print"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "814733c5-cf95-490a-bcf9-ea692201257e",
   "metadata": {},
   "source": [
    "## Run_n_times()\n",
    "\n",
    "In the video exercise, I showed you an example of a decorator that takes an argument: run_n_times(). The code for that decorator is repeated below to remind you how it works. Practice different ways of applying the decorator to the function print_sum(). Then I'll show you a funny prank you can play on your co-workers.\n",
    "\n",
    "def run_n_times(n):\n",
    "  \"\"\"Define and return a decorator\"\"\"\n",
    "  def decorator(func):\n",
    "    def wrapper(*args, **kwargs):\n",
    "      for i in range(n):\n",
    "        func(*args, **kwargs)\n",
    "    return wrapper\n",
    "  return decorator\n",
    "\n",
    "Instructions 1/3\n",
    "35 XP\n",
    "\n",
    "    Question 1\n",
    "    Add the run_n_times() decorator to print_sum() using decorator syntax so that print_sum() runs 10 times.\n",
    "    \n",
    "    \n",
    "    \n",
    "    Question 2\n",
    "    Use run_n_times() to create a decorator run_five_times() that will run any function five times.\n",
    "    \n",
    "    \n",
    "    \n",
    "    Question 3\n",
    "    Here's the prank: use run_n_times() to modify the built-in print() function so that it always prints 20 times!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05b767d4-0a63-4556-86e1-025a47ae05a6",
   "metadata": {},
   "source": [
    "## HTML Generator\n",
    "\n",
    "You are writing a script that generates HTML for a webpage on the fly. So far, you have written two decorators that will add bold or italics tags to any function that returns a string. You notice, however, that these two decorators look very similar. Instead of writing a bunch of other similar looking decorators, you want to create one decorator, html(), that can take any pair of opening and closing tags.\n",
    "\n",
    "def bold(func):\n",
    "  @wraps(func)\n",
    "  def wrapper(*args, **kwargs):\n",
    "    msg = func(*args, **kwargs)\n",
    "    return '<b>{}</b>'.format(msg)\n",
    "  return wrapper\n",
    "\n",
    "def italics(func):\n",
    "  @wraps(func)\n",
    "  def wrapper(*args, **kwargs):\n",
    "    msg = func(*args, **kwargs)\n",
    "    return '<i>{}</i>'.format(msg)\n",
    "  return wrapper\n",
    "\n",
    "Instructions 1/4\n",
    "25 XP\n",
    "\n",
    "    Question 1\n",
    "    Return the decorator and the decorated function from the correct places in the new html() decorator.\n",
    "    \n",
    "    \n",
    "    \n",
    "    Question 2\n",
    "    Use the html() decorator to wrap the return value of hello() in the strings <b> and </b> (the HTML tags that mean \"bold\").\n",
    "    \n",
    "    \n",
    "    \n",
    "    Question 3\n",
    "    Use html() to wrap the return value of goodbye() in the strings <i> and </i> (the HTML tags that mean \"italics\").\n",
    "    \n",
    "    \n",
    "    \n",
    "    Question 4\n",
    "    Use html() to wrap hello_goodbye() in a DIV, which is done by adding the strings <div> and </div> tags around a string.\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "54ad6d0e-494a-4720-9158-493aa5d98ce8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<i>Hello World</i>\n",
      "<div>hello and goodbye</div>\n"
     ]
    }
   ],
   "source": [
    "from functools import cache, wraps\n",
    "\n",
    "def bold(func):\n",
    "    @wraps(func)\n",
    "    def wrapper(*args, **kwargs):\n",
    "        msg = func(*args, **kwargs)\n",
    "        return '<b>{}</b>'.format(msg)\n",
    "    return wrapper\n",
    "\n",
    "def italics(func):\n",
    "    @wraps(func)\n",
    "    def wrapper(*args, **kwargs):\n",
    "        msg = func(*args, **kwargs)\n",
    "        return '<i>{}</i>'.format(msg)\n",
    "    return wrapper\n",
    "\n",
    "\n",
    "def html(open_tag, close_tag):\n",
    "    def decorator(func):\n",
    "        @wraps(func)\n",
    "        def wrapper(*args, **kwargs):\n",
    "            msg = func(*args, **kwargs)\n",
    "            return '{}{}{}'.format(open_tag, msg, close_tag)\n",
    "        # Return the decorated function\n",
    "        return wrapper\n",
    "    # Return the decorator\n",
    "    return decorator\n",
    "\n",
    "\n",
    "@html(\"<i>\", \"</i>\")\n",
    "def print_hello():\n",
    "    return \"Hello World\"\n",
    "    \n",
    "@html(\"<div>\", \"</div>\")\n",
    "def hello_goodbye():\n",
    "    return \"hello and goodbye\"\n",
    "    \n",
    "print(print_hello())\n",
    "print(hello_goodbye())\n",
    "    \n",
    "del print_hello, hello_goodbye, html, italics, bold, cache, wraps"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10b32c81-109c-4737-9ac1-25051c815cbd",
   "metadata": {},
   "source": [
    "## Timeout(): a real world example\n",
    "\n",
    "\n",
    "# *******************************************************************************************************************\n",
    "**We are going to finish up by looking at an example of a real-world decorator that takes an argument to give you a better sence of how they work.  \n",
    "\n",
    "# *******************************************************************************************************************\n",
    "# Lets imagine that we have some functions that occasionally either run for longer than we want them to or just hang and never return.  It would be nice if we could add some kind of timeout() decorator to those functions that will raise error if the function runs for longer than expected.  \n",
    "\n",
    "\n",
    "\n",
    "To create the timeout() decorator, we are going to use some functions from Python's signal module.  These functions have nothing to do with decorators, but understanding them willl help you understand the timeout() decorator I am about to show you.  \n",
    "\n",
    "# *******************************************************************************************************************\n",
    "**The raise_timeout() function simply raises a TimeoutError when it is called.  \n",
    "\n",
    "# *******************************************************************************************************************\n",
    "**The signal() function tells Python, when you see this signal whose number is signalnum, call the handler function. \n",
    "\n",
    "# *******************************************************************************************************************\n",
    "**In this case, we tell Python to call raise_timeout() whenever it sees the alarm signal.  The alarm() function lets us set an alarm for some number of seconds in the future.  Passing 0 to the alarm() function cancles the alarm.  \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "7cfc2181-34df-41dd-8c5d-0aa4791d92e4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import signal\n",
    "\n",
    "def raise_timeout(*args, **kwargs):\n",
    "    raise TimeoutError()\n",
    "\n",
    "\n",
    "# When an \"alarm\" signal goes off, call raise_timeout() function\n",
    "signal.signal(signalnum=signal.SIGALRM, handler=raise_timeout)\n",
    "\n",
    "\n",
    "# Set an alarm for 5 seconds\n",
    "signal.alarm(5)\n",
    "\n",
    "# Cancle the alarm\n",
    "signal.alarm(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34577eae-6edd-458f-a49a-fbe0fdb1e3ad",
   "metadata": {},
   "source": [
    "# *******************************************************************************************************************\n",
    "# *******************************************************************************************************************\n",
    "We'll start by creating a decorator that times out in exactly 5 seconds, and then build from there to create a decorator that takes the timeout length as an argument.  Our timeout_in_5s() decorator start off by defining a wrapper() function to return as the new decorated function.  Returning this function is what makes timeout_in_5s() a decorator.  \n",
    "\n",
    "# *******************************************************************************************************************\n",
    "First wrapper() sets an alarm for 5 seconds in the future.  Then it calls the function being decorated.  It wraps that call in a try block so that in the finally block we can cancle the alarm.  This ensures that the alarm either rings or gets canceled.  Remember when the alarm rings, Python calls the raise_timeout() function.  \n",
    "\n",
    "Lets use timeout_in_5s() to decorate a function that will definitely timeout, in our below example sleep_6s() sleep for 6 seconds and then print sleep 6 seconds.  If we call sleep_6s(), the 5-second alarmwill ring before it finishes sleeping, and Python will raise a TimeoutError.  \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e813641d-fe74-4185-a202-c79f0b2d6fb3",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "ename": "TimeoutError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTimeoutError\u001b[0m                              Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_17078/3540660984.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     30\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"sleep 6 seconds\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     31\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 32\u001b[0;31m \u001b[0msleep_6s\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     33\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     34\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0msleep_6s\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout_in_5s\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msignal\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/tmp/ipykernel_17078/3540660984.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     19\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     20\u001b[0m             \u001b[0;31m# Call the decorated func\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 21\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     22\u001b[0m         \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     23\u001b[0m             \u001b[0;31m# Cancel the alarm\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/tmp/ipykernel_17078/3540660984.py\u001b[0m in \u001b[0;36msleep_6s\u001b[0;34m()\u001b[0m\n\u001b[1;32m     27\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mtimeout_in_5s\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     28\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0msleep_6s\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 29\u001b[0;31m     \u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msleep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     30\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"sleep 6 seconds\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     31\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/tmp/ipykernel_17078/3540660984.py\u001b[0m in \u001b[0;36mraise_timeout\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# ***************************************************************************************************************** #\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mraise_timeout\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m     \u001b[0;32mraise\u001b[0m \u001b[0mTimeoutError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;31m# When an alarm signal goes off, call raise_timeout function\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTimeoutError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "import signal, time\n",
    "from functools import wraps\n",
    "\n",
    "\n",
    "# ***************************************************************************************************************** #\n",
    "def raise_timeout(*args, **kwargs):\n",
    "    raise TimeoutError()\n",
    "    \n",
    "# When an alarm signal goes off, call raise_timeout function\n",
    "signal.signal(signalnum=signal.SIGALRM, handler=raise_timeout)\n",
    "# ***************************************************************************************************************** #\n",
    "\n",
    "\n",
    "def timeout_in_5s(func):\n",
    "    @wraps(func)\n",
    "    def wrapper(*args, **kwargs):\n",
    "        # Set an alarmfor 5 seconds\n",
    "        signal.alarm(5)\n",
    "        try:\n",
    "            # Call the decorated func\n",
    "            return func(*args, **kwargs)\n",
    "        finally:\n",
    "            # Cancel the alarm\n",
    "            signal.alarm(0)\n",
    "    return wrapper\n",
    "\n",
    "@timeout_in_5s\n",
    "def sleep_6s():\n",
    "    time.sleep(6)\n",
    "    print(\"sleep 6 seconds\")\n",
    "    \n",
    "sleep_6s()\n",
    "\n",
    "del sleep_6s, timeout_in_5s, signal, time"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd1f58e9-165d-4f51-afaa-faa03ff7d573",
   "metadata": {},
   "source": [
    "**Now lets create a more useful version of the timeout() decorator.  This decorator takes an argument.  To decorate foo() we'll set the timeout to 5 seconds like we did previously.  But when decorating bar() we can set the timeout to 20 seconds.  This allows us to set a timeout that is appropriate for each function.  \n",
    "\n",
    "The timeout() is a function that returns a decorator, you can think of it as a decorator factory.  When you call timeout(), it cranks out a brand new decorator that timesout in any given seconds.  The first thing we need to do is define this new decorator that it will return.  That decorator begins by defining a wrapper() function to return, now because the n-seconds is available to the wrapper() function, we can set an alarm for n-seconds in the future.  The rest of the wrapper() func looks exactly like what we did before.  Notice that wrapper() returns the result of calling func(), decorator returns wrapper, and timeout() returns decorator.  \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0eeed289-7cb8-4732-9d26-53fe6174e77f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sleep for 5 seconds\n"
     ]
    }
   ],
   "source": [
    "import signal, time\n",
    "\n",
    "# ***************************************************************************************************************** #\n",
    "def raise_timeout(*args, **kwargs):\n",
    "    raise TimeoutError(\"Timeout Occured, out of the second range\")\n",
    "    \n",
    "# When an alarm signal goes off, call raise_timeout function\n",
    "signal.signal(signalnum=signal.SIGALRM, handler=raise_timeout)\n",
    "# ***************************************************************************************************************** #\n",
    "\n",
    "\n",
    "def timeout(n):\n",
    "    def decorator(func):\n",
    "        def wrapper(*args, **kwargs):\n",
    "            signal.alarm(n)\n",
    "            try:\n",
    "                return func(*args, **kwargs)\n",
    "            finally:\n",
    "                signal.alarm(0)\n",
    "        return wrapper\n",
    "    return decorator\n",
    "\n",
    "\n",
    "@timeout(7)\n",
    "def sleep_n_second(n):\n",
    "    time.sleep(n)\n",
    "    print(f\"sleep for {n} seconds\")\n",
    "            \n",
    "sleep_n_second(5)\n",
    "\n",
    "del sleep_n_second, timeout, signal, time, raise_timeout"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "751bcd22-c2b9-4486-b9a4-b5869a081bb3",
   "metadata": {},
   "source": [
    "## Tag your functions\n",
    "\n",
    "# *******************************************************************************************************************\n",
    "# *******************************************************************************************************************\n",
    "# *******************************************************************************************************************\n",
    "# Tagging something means that you have given that thing one or more strings that act as labels. For instance, we often tag emails or photos so that we can search for them later. You've decided to write a decorator that will let you tag your functions with an arbitrary list of tags. You could use these tags for many things:\n",
    "\n",
    "    Adding information about who has worked on the function, so a user can look up who to ask if they run into trouble using it.\n",
    "    Labeling functions as \"experimental\" so that users know that the inputs and outputs might change in the future.\n",
    "    Marking any functions that you plan to remove in a future version of the code.\n",
    "    Etc.\n",
    "\n",
    "Instructions\n",
    "100 XP\n",
    "\n",
    "    Define a new decorator, named decorator(), to return.\n",
    "    Ensure the decorated function keeps its metadata.\n",
    "    Call the function being decorated and return the result.\n",
    "    Return the new decorator.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "8ed2e11d-f398-49db-90d2-4c735e01590c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('test', 'this is a Do Nothing tag')\n"
     ]
    }
   ],
   "source": [
    "from functools import wraps\n",
    "\n",
    "\n",
    "def tag(*tags):\n",
    "    # Define a new decorator, named \"decorator\", to return\n",
    "    def decorator(func):\n",
    "        # Ensure the decorated function keeps its metadata\n",
    "        @wraps(func)\n",
    "        def wrapper(*args, **kwargs):\n",
    "            # Call the function being decorated and return the result\n",
    "            return func(*args, **kwargs)\n",
    "        wrapper.tags = tags\n",
    "        return wrapper\n",
    "    # Return the new decorator\n",
    "    return decorator\n",
    "\n",
    "\n",
    "@tag('test', 'this is a Do Nothing tag')\n",
    "def foo():\n",
    "    '''This func do nothing, just pass'''\n",
    "    pass\n",
    "\n",
    "print(foo.tags)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89b3727c-a6a1-496c-9142-73f4fbc14076",
   "metadata": {},
   "source": [
    "## Check the return type\n",
    "\n",
    "Python's flexibility around data types is usually cited as one of the benefits of the language. It can sometimes cause problems though if incorrect data types go unnoticed. You've decided that in order to ensure your code is doing exactly what you want it to do, you will explicitly check the return types in all of your functions and make sure they're returning what you expect. To do that, you are going to create a decorator that checks if the return type of the decorated function is correct.\n",
    "\n",
    "Note: assert is a keyword that you can use to test whether something is true. If you type assert condition and condition is True, this function doesn't do anything. If condition is False, this function raises an error. The type of error that it raises is called an AssertionError.\n",
    "Instructions 1/2\n",
    "50 XP\n",
    "\n",
    "    Question 1\n",
    "    Start by completing the returns_dict() decorator so that it raises an AssertionError if the return type of the decorated function is not a dictionary.\n",
    "    \n",
    "    \n",
    "    \n",
    "    Question 2\n",
    "    Now complete the returns() decorator, which takes the expected return type as an argument.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "38a84046-59e5-4b80-8056-a6ec845f3d56",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "foo() did not return a dict!\n",
      "{'a': 1, 'b': 2, 'c': 'f'}\n"
     ]
    }
   ],
   "source": [
    "def returns_dict(func):\n",
    "    # Complete the returns_dict() decorator\n",
    "    def wrapper(*args, **kwargs):\n",
    "        result = func(*args, **kwargs)\n",
    "        #############################################################################################################\n",
    "        assert type(result) == dict\n",
    "        return result\n",
    "    return wrapper\n",
    "\n",
    "\n",
    "@returns_dict\n",
    "def foo(value):\n",
    "    return value\n",
    "\n",
    "\n",
    "try:\n",
    "    print(foo([1,2,3]))\n",
    "except AssertionError:\n",
    "    print('foo() did not return a dict!')\n",
    "\n",
    "\n",
    "try:\n",
    "    print(foo({'a':1, 'b':2, 'c':'f'}))\n",
    "except AssertionError:\n",
    "    print('foo() did not return a dict!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "d7af42f4-775d-4a30-a8cc-2823c2bb47b6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "returns check passed\n",
      "{0: 'h', 1: 'e', 2: 'l', 3: 'l', 4: 'o', 5: 'W', 6: 'o', 7: 'r', 8: 'l', 9: 'd'}\n",
      "returns check passed\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "('b', 'o', 'n', 'j', 'o', 'u', 'r', ' ', 's', 'a', 'w', 'a')"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Now complete the returns() decorator, which takes the expected return type as an argument\n",
    "from functools import wraps\n",
    "\n",
    "\n",
    "def returns(return_type):\n",
    "    def decorator(func):\n",
    "        @wraps(func)\n",
    "        def wrapper(*args, **kwargs):\n",
    "            result = func(*args, **kwargs)\n",
    "            assert type(result) == return_type\n",
    "            print('returns check passed')\n",
    "            return result\n",
    "        return wrapper\n",
    "    return decorator\n",
    "\n",
    "\n",
    "@returns(dict)\n",
    "def my_func(words):\n",
    "    return {i:j for i,j in enumerate(words)}\n",
    "\n",
    "print(my_func('helloWorld'))\n",
    "\n",
    "\n",
    "@returns(tuple)\n",
    "def my_func2(words):\n",
    "    return tuple(words)\n",
    "\n",
    "my_func2('bonjour sawa')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "e07ffa33-9cba-4be3-ab1c-903bd96c1c82",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('h', 'e', 'l', 'l', 'o')"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple('hello')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c428ce6d-4927-4e7b-8c98-92fcc0bef2ff",
   "metadata": {},
   "source": [
    "## Great job!\n",
    "\n",
    "\n",
    "**You've covered a lot in this course.  In the first chapter, you learned how to make high-quality functions by giving them docstrings and by making sure that they only Do One Thing.  Remember the DRY, Dont Repeat Yourself, helped you notice when you need to pull part of your code into a resuable function.  You also learned how Python passes arguments to functions, and difference between mutable and immutable variables.  In the chapter on context managers, you learned how to use the keyword with to enter and then exit a context.  You also learned how to write your own text managers by using the @contextlib.contextmanager() decorator.  You also spend a lot of time in this course understanding decorators: how thay work, how to use them, and how to write decorators of your own.  Finally in chapter 4, you learned how to use @functools.wraps(func) to make sure your decorated function maintains their metadata.  And you learned hwo to write decorators that take arguments.  \n",
    "\n",
    "\n",
    "It is been an honor to spend this time with this course. \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.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}