02_functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "## Functions\n",
    "\n",
    "Thus far, we have sent the Python interpreter two types of statements:\n",
    "\n",
    "1. Arithmetic Expressions\n",
    "2. Variable Assignments\n",
    "\n",
    "These types of statements are useful, but they are not enough to build more complex programs. We will now need to use **functions** - special pieces of code designed to perform particular tasks. What exactly is a function? The best way to understand this core concept is to consider the following analogy: \n",
    "\n",
    "Suppose that you have a pet dog. Your dog is well-trained, and knows how to respond to several simple commands: \n",
    "\n",
    "1. \"Sit!\"\n",
    "2. \"Down!\"\n",
    "3. \"Stay!\"\n",
    "\n",
    "There is a *procedure* associated with each of these commands, meaning that when your dog hears the command, it *does something* in response. The python interpreter is just like your well-trained dog - it knows a small set of commands, and when you type the name of a given command, it will execute the procedure corresponding to that name. Each of these commands that the Python interpreter knows is a **function**. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "For example, Python has a function called `round` that can round decimal numbers to the nearest integer. First, we'll show you how to *call* the function in the code cell below (think of the word \"call\" as meaning \"issue a command\") and then we'll explain what each part of the code does. We can tell Python to round up the number `7.8` to `8.0` by using the `round` function as demonstrated in the code cell below. Run the code in the code cell below using Shift-Enter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(7.8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "The line `round(7.8)` that you typed above is known as a *function call* statement. As you can see, when you called the function `round`, Python executed the appropriate procedure and *returned* the result. Now let's look at the details of this function call to understand how it works. The line above consists of four parts:\n",
    "\n",
    "1. The *function name*: `round`\n",
    "2. An open parenthesis `(`\n",
    "3. The *function argument*: `7.8`\n",
    "3. A closing parenthesis `)`\n",
    "\n",
    "All of these parts are important to making our function call statement work. We need to type the function name so that Python knows what specific trick that we want it to perform. We need to provide an *argument* (a value between the parentheses) because we don't just want Python to \"do something\" - rather, we want it to \"do something to X.\" We need to tell it *what* exactly we want it to `round`, and we do so by putting the number we want rounded in between the parentheses. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "<span style=\"color:blue;font-weight:bold\">Exercise</span>: Call the `round` function with an argument value of `5.2`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true,
    "tags": [
     "exercise"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(5.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "deletable": false,
    "editable": false,
    "strategicml": {
     "execution_time": 1584756402129,
     "exercise_id": "8791a631-6b84-491b-8eee-54e5b28f567c",
     "points": 1
    },
    "tags": [
     "test"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"background-color:#e8fcef\n",
       ";color:#333333;padding:10px;border-style:solid;border-width:2px;border-color:#038c33\">\n",
       "<div style=\"font-weight:bold\">Correct!</div>\n",
       "</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hint = \"Did you call the <code>round</code> function with the argument <code>5.2</code> appropriately placed between a pair of parentheses <code>()</code>?\"\n",
    "assert get_sanitized_input() == 'round(5.2)', hint\n",
    "assert _ == 5, hint\n",
    "success()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "Let's practice with calling functions using another one of Python's builtin functions - the `abs` function. This function will find the absolute value of whatever number that we give it as its argument, so `abs(-5)` will return `5` and `abs(6)` will return 6."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "<span style=\"color:blue;font-weight:bold\">Exercise</span>: Call the `abs` function with an argument value of `-8`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true,
    "tags": [
     "exercise"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(-8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "deletable": false,
    "editable": false,
    "strategicml": {
     "execution_time": 1584756930397,
     "exercise_id": "28654f04-9b33-48b7-bfef-d490f5c887ff",
     "points": 1
    },
    "tags": [
     "test"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"background-color:#e8fcef\n",
       ";color:#333333;padding:10px;border-style:solid;border-width:2px;border-color:#038c33\">\n",
       "<div style=\"font-weight:bold\">Correct!</div>\n",
       "</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hint = \"Did you call the <code>abs</code> function with the argument <code>-8</code> appropriately placed between a pair of parentheses <code>()</code>?\"\n",
    "assert get_sanitized_input() == 'abs(-8)', hint\n",
    "assert _ == 8, hint\n",
    "success()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "Sometimes, we want Python to perform a task that requires multiple inputs - for example, to find the largest number out of a list of many numbers. Fortunately, Python has functions that allow us to pass more than one value as an argument. Let's see how this works with the following example, which calls the `max` function with three numerical arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(3,4,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "As you can see, the `max` function returns the largest value out of all of its arguments. Notice now that our function call is slightly more complex than in the previous example. It consists of: \n",
    "\n",
    "1. The *function name*: `max`\n",
    "2. An open parenthesis `(`\n",
    "3. The multiple *function arguments*, separated by commas: `3,4,5`\n",
    "4. A closing parenthesis `)`\n",
    "\n",
    "While some functions do not accept arguments at all, and others (like the `abs` function above) accept only a specific number of arguments, there is no limit to how many arguments we can pass to the `max` function. The only requirement is that we put a `,` in between each argument. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "<span style=\"color:blue;font-weight:bold\">Exercise</span>: We can also call the `min` function, which returns the smallest value out of all of its arguments. Call the `min` function with the arguments, `5`, `7`,`2` and `4` (make sure that your arguments are in that order):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true,
    "tags": [
     "exercise"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(5,7,2,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "deletable": false,
    "editable": false,
    "strategicml": {
     "execution_time": 1584756938764,
     "exercise_id": "0dbc9e05-9655-4930-908c-8d9370d46d15",
     "points": 1
    },
    "tags": [
     "test"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"background-color:#e8fcef\n",
       ";color:#333333;padding:10px;border-style:solid;border-width:2px;border-color:#038c33\">\n",
       "<div style=\"font-weight:bold\">Correct!</div>\n",
       "</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import re\n",
    "hint = \"Did you call the <code>min</code> function with the arguments <code>5, 7, 2, 4</code> appropriately placed between a pair of parentheses <code>()</code>?\"\n",
    "assert re.sub(\"\\s+\", \"\", get_sanitized_input()) == 'min(5,7,2,4)', hint\n",
    "assert _ == 2, hint\n",
    "success()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "Sometimes, we might not be sure what a given function does, or how to use it. When that happens, we can find out more information by typing the function-name, then holding the `Shift` key and subsequently pressing the `Tab` key."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "<span style=\"color:red;font-weight:bold\">Try It</span>: Use the `Shift-Tab` technique described above to view the help information for the function `round`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "?round "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "### Functions and Variables\n",
    "\n",
    "Recall what we learned about variables in the last section: variables are boxes in which we can store values. For example, we can store `4.3` inside a box called `a_number` by executing the cell below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "a_number = 4.3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "We can use variables in our function calls the same way that we would use the raw numbers themselves. For example, we can call the `round` function using `a_number` as its argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(a_number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "Functions like `round` *return* a result, which is the number printed on your screen as the output of the code cell after you call them. We can store this return value inside of a variable just like any other value, as can be seen in the following code cell: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "rounded_number = round(a_number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "If we peek inside the box of the variable `rounded_number`, we can see that the the correct value is stored inside:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rounded_number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "<span style=\"color:blue;font-weight:bold\">Exercise</span>: Use the `min` function to find the minimum value from the numbers `3`, `5`, `2`, and `4`. Store this result in the variable `minimum_value`, and print the result on the screen by typing the variable name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true,
    "tags": [
     "exercise"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "minimum_value = min(3,5,2,4)\n",
    "\n",
    "minimum_value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "deletable": false,
    "editable": false,
    "scrolled": true,
    "strategicml": {
     "execution_time": 1584757002100,
     "exercise_id": "32acbd50-91a5-44ba-8ad3-4b4c46d22fd9",
     "points": 1
    },
    "tags": [
     "test"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"background-color:#e8fcef\n",
       ";color:#333333;padding:10px;border-style:solid;border-width:2px;border-color:#038c33\">\n",
       "<div style=\"font-weight:bold\">Correct!</div>\n",
       "</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "input_lines = [line.strip() for line in get_sanitized_input().splitlines()]\n",
    "assert len(input_lines) == 2, \"Hint: your solution for this exercise should have two lines of code - one line to set the value of the <code>minimum_value</code> variable, and a second line to display its value on the screen.\"\n",
    "assert minimum_value == 2, \"Did you perform the function call <code>min(3,5,2,4)</code> and store its result in the variable <code>minimum_value</code>?\"\n",
    "assert input_lines[1] == 'minimum_value', \"Did you print the value stored in the variable `minimum_value` by typing this variable name on its own line?\"\n",
    "success()"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": null,
  "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.3"
  },
  "strategicml": {
   "lesson_id": "f8d98ef0-0c83-4f3e-afdb-d9237aeb21e5",
   "release": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}