Exercises/EN/Basic/10_Functions_Intermediate_Solutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## About This Notebook\n",
    "\n",
    "We started to work with functions in previous notebook. We will continue to explore this world by:\n",
    "- Exploring what happens if we attempt to mess with the ``built-in`` functions.\n",
    "- Learning what are *default arguments*.\n",
    "- Finding how to lean about particular Python functions through *documentation*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Interfering with the Built-in Functions\n",
    "Let's suppose we create a function called `find_sum()` like the one below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def find_sum(my_list):\n",
    "    sum = 0\n",
    "    for element in my_list:\n",
    "        sum += element\n",
    "    return sum\n",
    "\n",
    "list_a = [5, 2, 11]\n",
    "find_sum(list_a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function `find_sum()` does the exact same thing just as the built-in `sum()` function, see below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(list_a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that `find_sum()` and `sum()` gives out the same result and **we might be tempted to name the find_sum() function simply sum()**.\n",
    "\n",
    "However, using the name ``sum()`` for our function above interferes with the ``built-in sum() function``. If we name our function sum(), and if we try to call sum(), Python won't run the built-in sum() function anymore, but instead, it will run the sum() function that we wrote.\n",
    "\n",
    "We can rewrite our function and return the string \"This function doesn't not sum up the number in the list\" instead of returning the sum of the elements of the list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"This function doesn't not sum up the number in the list\""
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#the sum() function we wrote takes precedences over the built-in sum() function\n",
    "def sum(my_list):\n",
    "    a_string = \"This function doesn't not sum up the number in the list\"\n",
    "    return a_string\n",
    "\n",
    "list_a = [5, 2, 11]\n",
    "sum(list_a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">**We should not use the name of built-in functions to name our functions**. Not only can it confuse your fellow collegues or other people who might read your code later, but also lead to some abnormal function behaviors."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Variable Names and Built-in Functions\n",
    "\n",
    "In the previous session, we learned that we shouln't use the names of built-in functions to name our own functions. Now, let's observe the code below. We first assign 20 (the result of the sum 5 + 15) to a variable named sum. This would then cause interferes with the built-in sum() function -- when we call `sum()`. Python would therefore looks for the value stored in the sum variable and instead of calling the built-in function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'int' object is not callable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-4-be4c53dcbe1f>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0msum\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[0mlist_a\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m11\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0msum\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlist_a\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'int' object is not callable"
     ]
    }
   ],
   "source": [
    "del sum\n",
    "sum = 5 + 15\n",
    "sum\n",
    "list_a = [5, 2, 11]\n",
    "sum(list_a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The sum is therefore a variable, stored with the integer 20 and when we run sum(list_a), we are running 20(list_1) and instead of the sum() function. Hence we got the error message <b> 'int' object is not callable</b>.\n",
    "\n",
    "How do we avoid built-in functions and accidentally name it to our own function?\n",
    "A good way to tell built-in function is by the highlight in the editor."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "````python\n",
    "sum() #highlighted \n",
    "this_is_a_normal_function() #not highlighted\n",
    "len() #highlighted \n",
    "````"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See more built-in functions under [this](https://docs.python.org/3/library/functions.html).</p>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Default Arguments\n",
    "\n",
    "When we write a function,  we can initiate parameters with certain default values --- these are known as the default arguments.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Initiate the constant parameter with a default argument of 5\n",
    "def increment_by_5(a, constant = 5):\n",
    "    return a + constant\n",
    "\n",
    "increment_by_5(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the code above, we created the `increment_by_5()` function with two parameters: a and constant. When we call the function, we only need to pass in one positional argument: in the example above, 5.\n",
    "From the code above we can deduce that the `increment_by_5` function used the argument 5 for the parameter constant.\n",
    "\n",
    "We can also modify our default arguments if we want like below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "25\n",
      "30\n",
      "15\n",
      "25\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "print(increment_by_5(5, constant = 10))\n",
    "print(increment_by_5(5, constant = 20))\n",
    "print(increment_by_5(5, constant = 25))\n",
    "\n",
    "#Alternative:\n",
    "\n",
    "print(increment_by_5(5, 10))\n",
    "print(increment_by_5(5, 20))\n",
    "print(increment_by_5(5, 25))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If all parameters have default arguments, then it is possible to call a function without passing in any argument. Otherwise we will get an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# all parameters have default arguments\n",
    "def increment_by_5(a = 1, constant = 5):\n",
    "    return a + constant\n",
    "\n",
    "increment_by_5()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "increment_by_5() missing 1 required positional argument: 'a'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-8-78bf8ed01c28>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0ma\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mconstant\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mincrement_by_5\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: increment_by_5() missing 1 required positional argument: 'a'"
     ]
    }
   ],
   "source": [
    "# Normal function\n",
    "def increment_by_5(a, constant = 5):\n",
    "    return a + constant\n",
    "\n",
    "increment_by_5()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Default arguments can be useful when we'll use an argument frequently and this can save us some time when we reuse the functions. Default arguments are also very useful for building complex functions.\n",
    "\n",
    "We can now try to build a function that opens a CSV file and makes use of default arguments at the same time.\n",
    "\n",
    "### Task 1.7.3:\n",
    "1. Edit the `open_dataset()` function below and add the name of iOS apps data set ('AppleStore.csv') as a default argument for the file_name parameter.\n",
    "2. Without passing any argument, try to use the `open_dataset()` function to open the AppStore.csv file and assign the data set to a variable named `apps_data`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# INITIAL CODE\n",
    "def open_dataset(file_name='AppleStore.csv'):\n",
    "    \n",
    "    opened_file = open(file_name, encoding=\"utf8\")\n",
    "    from csv import reader\n",
    "    read_file = reader(opened_file)\n",
    "    apps_data = list(read_file)\n",
    "    \n",
    "    return apps_data\n",
    "\n",
    "apps_data = open_dataset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. The Official Python Documentation (IMPORTANT)\n",
    "\n",
    "It will come in handy when you get in touch with more complex Python Programming, [the official Python documentation](https://docs.python.org/3/) is extremely useful for all Python users.\n",
    "For example if you want to get to know more about the sum() function, go to [the search page](https://docs.python.org/3/search.html) and search for \"sum\" or \"sum built-in\", then we can see the search result immediate.\n",
    "\n",
    "The documentation of the ``sum()`` function ends where the next function, ``super()``, begins.\n",
    "On the first line, we can see all the parameters of the sum() function:\n",
    "sum(iterable, /, start=0)\n",
    "\n",
    "We can see how useful the official Python documentation is. We can find information about all the parameters that this function takes as well as its default arguments (try to search for function \"open\" or \"open built-in\").\n",
    "\n",
    ">This official Python documentation will be your best friend in your data science journey. It does seem a little bit technical and a bit scary, but don't worry, it is absolutely normal to feel this way. We will definitely have a lot of fun in this Python journey together :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 1.7.4:\n",
    "1. Find the documentation of the `round()` function. Link to [the search page](https://docs.python.org/3/search.html).\n",
    "2. Read and try to understand all the documentation of the `round()` function.\n",
    "3. Try to use the right parameters and arguments, can you:\n",
    "    - Round 3.41 to one decimal point? Assign the result to a variable name of your choice.\n",
    "    - Round 0.532316 to two decimal points. Assign the result to a variable name of your choice.\n",
    "    -Round 892.3265621777 to five decimal points. Assign the result to a variable name of your choice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Start your code below:\n",
    "\n",
    "one_decimal = round(3.41, 1)\n",
    "two_decimals = round(0.532316, 2)\n",
    "five_decimals = round(892.3265621777, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Multiple Return Statements (OPTIONAL)\n",
    "\n",
    "Is it possible to build a function with multiple return statements?\n",
    "For example we want to write a function that it's flexible enough to return either the sum of the two numbers or the difference.\n",
    "\n",
    "How can we achieve this? \n",
    "\n",
    "Fortunately, it is possible to use multiple return statements.\n",
    "Try to understand the following code:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "def sum_or_difference(x, y, do_sum =True):\n",
    "    if do_sum: \n",
    "        return x + y\n",
    "    else:\n",
    "        return x - y\n",
    "    \n",
    "print(sum_or_difference(20, 10, do_sum = True))\n",
    "print(sum_or_difference(20, 10, do_sum = False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have implemented the following logic in the function above:\n",
    "\n",
    "- If do_sum has a value of True, then we return x + y.\n",
    "- Else (if do_sum is False), we return x - y.\n",
    "\n",
    "We can simply put the function above without using an <b> else </b> statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "def sum_or_difference(x, y, do_sum =True):\n",
    "    if do_sum: \n",
    "        return x + y\n",
    "    \n",
    "    return x - y\n",
    "\n",
    "\n",
    "print(sum_or_difference(20, 10, do_sum = True))\n",
    "print(sum_or_difference(20, 10, do_sum = False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above approach works just as the same as the previous function because a function stops executing its rest code as soon as a return statement is execute. Even if there are some other important lines after that <b> return </b> statement, it won't get executed.\n",
    "\n",
    "If do_sum is `True`, then return x + y is executed, so the function stops, and it doesn't execute any of the remaining code.\n",
    "If do_sum is `Flase`, then return x + y will not be executed and the function will move forward the eventually reaches the end which is the next return statement: return a - b."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Returning Multiple Variables\n",
    "In the previous session, we wrote a function that can either return the sum or the difference of two numbers. \n",
    "\n",
    "Fortunately, in Python we are able to build functions that can return more than just one variable. See below:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(20, 10)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def sum_and_difference(x, y):\n",
    "    a_sum = x + y\n",
    "    difference = x - y\n",
    "    \n",
    "    return a_sum, difference\n",
    "\n",
    "\n",
    "sum_diff = sum_and_difference(15,5) #Passed 15 and 5 as arguments to the sum_and_difference() function\n",
    "sum_diff #two values are returned at the end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that both the sum and the difference of our given numbers are returned as the final output. The order of the variables in the return statement is important. For example:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 20)\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "def sum_and_difference(x, y):\n",
    "    a_sum = x + y\n",
    "    difference = x - y\n",
    "    \n",
    "    return difference, a_sum #the order of the return statement is important\n",
    "\n",
    "\n",
    "sum_diff = sum_and_difference(15,5) \n",
    "print(sum_diff)\n",
    "\n",
    "print(type(sum_diff))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The order of the final output above is different than the function we had previously. Please pay extra attention to how you construct your return statement.\n",
    "\n",
    "One thing that might surprise you is that the type of the output from the sum_and_difference is a <b>tuple </b>, which is a data type that is **very similar to a list**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(sum_diff)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">A tuple is usually used for storing multiple values. \n",
    "\n",
    "We can create a tuple just as easy as creating a list, see below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 'a', 2.5]\n",
      "<class 'list'>\n",
      "(1, 'a', 2.5)\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "this_is_a_list = [1, 'a', 2.5]\n",
    "this_is_a_tuple = (1, 'a', 2.5)\n",
    "\n",
    "print(this_is_a_list)\n",
    "print(type(this_is_a_list))\n",
    "\n",
    "print(this_is_a_tuple)\n",
    "print(type(this_is_a_tuple))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The only construction difference between a list and a tuple is a list is surrounded by brackets and a tuple is surrounded by parentheses.\n",
    "\n",
    ">The major difference between tuples and lists is that exisiting values of a list can be modified but a tuple not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1\n",
      "2.5\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "this_is_a_list = [1, 'a', 2.5]\n",
    "this_is_a_tuple = (1, 'a', 2.5)\n",
    "\n",
    "#Just as lists, tuples support positive and negative indexing.\n",
    "print(this_is_a_list[0])\n",
    "print(this_is_a_tuple[0])\n",
    "print(this_is_a_list[-1])\n",
    "print(this_is_a_tuple[0])\n",
    "\n",
    "#A list can be modified\n",
    "this_is_a_list[0] = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-20-8a39f4936b70>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m#But on the contrary, a tuple cannot modify the existing values.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mthis_is_a_tuple\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "#But on the contrary, a tuple cannot modify the existing values.\n",
    "this_is_a_tuple[0] = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">The non-modifiable property is called ``immutable``. Tuples are one of these immutable data types because we can't change their state after they've been created.\n",
    "On the other side, lists are mutable data types because we can change their values after they've been created.\n",
    "\n",
    "If we want to modify tuples or any other immutable data types, the only way to change their state is to recreate them.\n",
    "\n",
    "Below is a list of mutable and immutable  data types.\n",
    "- Mutable: Lists, Dictionaries\n",
    "- Immutable: Tuples, Integers, Floats, Strings, Booleans."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. Functions --- Code Running Quirks\n",
    "\n",
    "Do you know that parameters and return statements are optional for a function. See the example below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a function that doesn't have parameters nor a return statement\n"
     ]
    }
   ],
   "source": [
    "def print_statement():\n",
    "    a_string = \"This is a function that doesn't have parameters nor a return statement\"\n",
    "    print(a_string)\n",
    "    \n",
    "print_statement()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions that don't have a return statement just simply don't return any value.\n",
    "\n",
    "Well, theoretically, they return a <b> `None` </b> value, which just means the absence of a value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a function that doesn't have parameters nor a return statement\n",
      "None\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def print_statement():\n",
    "    a_string = \"This is a function that doesn't have parameters nor a return statement\"\n",
    "    print(a_string)\n",
    "    \n",
    "f = print_statement()\n",
    "print(f)\n",
    "type(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the function above, notice that we assigned a text to a variable named a_string. What is worth noticing here is that we cannot access a_string outside the function. If we try the following, we would get an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'a_string' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-23-eecb07b2436f>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[1;31m#Outside the function\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 8\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma_string\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'a_string' is not defined"
     ]
    }
   ],
   "source": [
    "\n",
    "def print_statement():\n",
    "    #Inside the function\n",
    "    a_string = \"This is a function that doesn't have parameters nor a return statement\"\n",
    "    print(a_string)\n",
    "\n",
    "#Outside the function\n",
    "print(a_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that what's inside a function will only be executed after that function is called. For example, if we have some error inside that function, there won't be any error message raised until we call that function. See example below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Code finished running, but no error was raised\n"
     ]
    }
   ],
   "source": [
    "def do_something():\n",
    "    \"I cannot be divided\" / 5\n",
    "    \n",
    "print('Code finished running, but no error was raised')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But we will see the error message if we call that function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Now we see the error:\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for /: 'str' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-25-89ced6dfa891>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Now we see the error:'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mdo_something\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-25-89ced6dfa891>\u001b[0m in \u001b[0;36mdo_something\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mdo_something\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m     \u001b[1;34m\"I cannot be divided\"\u001b[0m \u001b[1;33m/\u001b[0m \u001b[1;36m5\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Now we see the error:'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0mdo_something\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for /: 'str' and 'int'"
     ]
    }
   ],
   "source": [
    "def do_something():\n",
    "    \"I cannot be divided\" / 5\n",
    "    \n",
    "print('Now we see the error:')\n",
    "do_something()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. Scopes --- Global and Local\n",
    "\n",
    "Observe the following function carefully:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.1415926\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'x' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-26-a42445f3a41a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0mprint_constant\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m \u001b[0mx\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'x' is not defined"
     ]
    }
   ],
   "source": [
    "def print_constant():\n",
    "    x = 3.1415926 \n",
    "    print(x)\n",
    "    \n",
    "print_constant()\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that we get an error when x is called. However, we have already called the function print_constant(), **how come x is not defined?** x is clearly defined inside the `print_constant()` function.\n",
    "\n",
    "The reason for this is that Python saves the variable <b> x </b> only temporarily. **Python saves x into a kind of temporary memory, which is immediately erased after the print_constant() function finishes running**. This explains why we still get the x is not defined error when we try to call x outside of the `print_constant()` function. Because it is erased as soon as the print_constant() function finishes running.\n",
    "\n",
    "However, this kind of temporary memory storage doesn't apply to the code that is being run outside function definitions.\n",
    "If we try to define x = 3.1415926 for example in our main program , or outside function definitions, we can use x later on without having any problem or worry about that it was erased from the memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is not erased\n",
      "we can call x now\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3.1415926"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 3.1415926\n",
    "\n",
    "print('x is not erased')\n",
    "print('we can call x now')\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You see that x now we don't get an error message by calling x.\n",
    "\n",
    "There are several advantages to have such temporary memory associated with a function. For example, if we initialize a variable x = 123 in the main program and then execute x = 3.1415926 in the body of a function, the x variable of the main program is not being overwritten."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.1415926\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "123"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 123\n",
    "\n",
    "def print_constant():\n",
    "    x = 3.1415926 \n",
    "    print(x)\n",
    "    \n",
    "print_constant()\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You see that with memory isolation, we don't have to worry about overwriting variables from the main program when we write functions, or vice-versa. This can be extremely helpful when we write some large and complicated programs, we don't have to remember all the variable names declared in the main program.\n",
    "\n",
    ">The part of a program where a variable can be accessed is often called <b>scope</b>.\n",
    "\n",
    "><b>Global scope</b> is known as the variables defined in the main program and <b>local scope</b> is known as the variables defined inside a function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 1.7.8\n",
    "Create a function named exponential() that takes in a single parameter named x.\n",
    "- Inside the function definition:\n",
    "  - Assign 3.14 to a variable named `e`.\n",
    "  - Print e.\n",
    "- The function should return e to the power of x.\n",
    "- Call the `exponential()` function with an argument of 2. Assign the result to a variable named result.\n",
    "- Hypothesize what you should see if you printed e in the main program after calling the `exponential()` function. Print e to confirm or reject your hypothesis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.14\n",
      "9.8596\n"
     ]
    }
   ],
   "source": [
    "# Start your code below:\n",
    "\n",
    "def exponential(x):\n",
    "    e = 3.14\n",
    "    print (e)\n",
    "    return pow(e, x)\n",
    "\n",
    "result = exponential(2)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9. Scopes --- Searching Order\n",
    "\n",
    "Let's take a look of the code below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50\n",
      "20\n",
      "70\n"
     ]
    }
   ],
   "source": [
    "x = 50\n",
    "y = 20\n",
    "\n",
    "def add():\n",
    "    print(x)\n",
    "    print(y)\n",
    "    return x+ y\n",
    "\n",
    "my_result = add()\n",
    "print(my_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You might be surprised that the code above didn't throw any error.\n",
    "\n",
    ">When a variable is accessed from within a function, Python first searches in the local scope (inside the function's definition) to see if there are any matching variable defined here. If Python doesn't find the variables inside the function's definition, it will continue to search in the global score ( the scope of the main program)\n",
    "\n",
    "And now let's take a look of the code below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "2\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "x = 50\n",
    "y = 20\n",
    "\n",
    "def add():\n",
    "    x = 5\n",
    "    y = 2\n",
    "    print(x)\n",
    "    print(y)\n",
    "    return x+ y\n",
    "\n",
    "my_result = add()\n",
    "print(my_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the code above we see that the local scope is prioritized relative to the global scope. If we define x and y with different values within the local scope (like x = 5 and y = 2), Python will use those values instead of the x and y that are lying in the main program, and we'll get a different result.\n",
    "\n",
    ">Pay attention that even though Python searches the global scope if a variable is not found in the local scope, but the reverse doesn't apply here— Python won't search the local scope if a variable is not found in the global scope.\n",
    "\n",
    "Remember the error that we had at the beginning?\n",
    "To refresh your member, see below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.1415926\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def print_constant():\n",
    "    x = 3.1415926 \n",
    "    print(x)\n",
    "    \n",
    "print_constant()\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If this concept is still confusing to you, for a more demonstrative overview, go ahead and check out this [video](https://www.youtube.com/watch?v=r9LtArXOYjk)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}