Lessons/Lesson19_Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Writing Functions\n",
    "\n",
    "**Remember:**\n",
    "- You've already used lots of built-in functions in python. Examples are `print()` and `sum()`. Can you think of others?\n",
    "- Functions take an input (_arguments_) and _return_ an output.\n",
    "\n",
    "Guess what? You can also make your own functions! Why would you want to do this? \n",
    "- Have you ever copied and pasted code because you want to reuse it but with different data or in a slightly different way? If so, you might want to make that code into a function! \n",
    "- Using functions also makes your code much easier to read.\n",
    "\n",
    "## Anatomy of a Function\n",
    "Functions have an **input** and an **output**. We provide the input, and then the function does things to generate the output. Another way to put this is functions *take* arguments (i.e. input) and *return* an output.\n",
    "\n",
    "```\n",
    "# Anatomy of a function\n",
    "def my_function(input):\n",
    "    # do things to input\n",
    "    return(output)\n",
    "```\n",
    "\n",
    "Let's take a look at a few different analogies to get a better idea of what functions are.\n",
    "\n",
    "## Function Analogies\n",
    "\n",
    "\n",
    "|\"Function\" name| Input: what \"function\" takes  | Under the hood: what \"function\" does  | Output: what \"function\" returns |\n",
    "|---|---|---|---|\n",
    "|_Vending machine_|Money & snack choice|Some computational/mechanical process|Snack|\n",
    "|_Google maps_|Start & end location|Finds fastest route|Directions for fastest route|\n",
    "\n",
    "\n",
    "Now let's try a real example.\n",
    "\n",
    "## Writing and using a simple function\n",
    "\n",
    "**Let's write a function called `power` that calculates the power of two numbers (a base and an exponent).** It **takes** two numbers - a base and an exponent - and **returns** the base raised to the exponent. It's important to document what your function does so other people can use it.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "# write function to find power of two numbers\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's test our function out! You can use any two numbers as the input to the function.\n",
    "\n",
    "Remember that each input for a function is called an **argument**. Each argument is given a variable name which allows us to use that input in our function. If you include the argument names, then you can include the numbers in any order you want:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# using numbers as input\n",
    "# explicitly name arguments (order doesn't matter)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, you should get the same answer for both.\n",
    "\n",
    "If you decide to just include the numbers and not the names, then you have to make sure the numbers are in the correct order (i.e. the order in which the arguments are defined in the function - base first and exponent second):\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# using numbers as input\n",
    "# using the order of the arguments (order matters)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, you should get a different answer for each. What is the base and what is the exponent for each of these examples?\n",
    "\n",
    "You can also use variables as input:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# using variables as input\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just like built-in functions, you can also save the output of the function to a variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# saving it to a variable\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try other inputs, because that's the real power of using functions (no pun intended)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Feel free to try out other inputs as well!\n",
    "\n",
    "## Scope of argument variables\n",
    "The input arguments in the power function are `base` and `exponent`. These *variables* are defined only within the context of the function, not in the global environment. So we can print out `base` and `exponent` within the function, but **if we try to print out either of these variables outside of the function, we will get an error** (unless it's defined in your global environment). Let's try it out. **What do you think happens if we try to print out `base` outside of the function?**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "# print base outside of function \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It doesn't exist! This is called the _scope_ of the variables - they can only be seen in the function, but not in the global environment.\n",
    "\n",
    "## Optional arguments with default values\n",
    "If you want something to normally happen, but have the option for it to not happen, you can use _optional arguments_. For instance, you may want the `power` function to, by default, square the `base` variable (i.e. have `exponent=2`), but give the user the option to change it if they want. In this case, if the user doesn't specify a value for exponent, the function uses the _default_ option, which is defined where you define the argument in the function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write function to find power of two numbers with a default option\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Note:_ You have to include arguments that don't have default values. If not, then you get an error because there is nothing stored in that variable in the function, so the code inside can't be executed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "# what happens if you run this line? (uncomment it)\n",
    "#power(exponent=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What argument are we missing here?\n",
    "\n",
    "## Argument variable names\n",
    "\n",
    "Another important note is that **it doesn't matter what we call the input arguments.** Right now, the input arguments are `base` and `exponent`. Let's try changing them to something totally random, maybe `pizza` and `pie`. Pizza and pie probably doesn't have anything to do with the input (two numbers), but the computer doesn't know that!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use pizza as variable name\n",
    "#  function to find power of two numbers\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Although you can name your input arguments anything since the computer doesn't care, **you actually want to name them something useful so that people reading the code (including your future self!) can more easily understand what's going on.** Thinking of good variable names can be hard, but it's important!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nice job! You've learned so much about writing functions.\n",
    "\n",
    "## Summary of functions\n",
    "- Functions are used to make your code easier to read and reuse.\n",
    "- Functions take an input (_arguments_) and _return_ an output.\n",
    "- Arguments are variables that only exist inside the function.\n",
    "- You can have _default_ arguments for your function.\n",
    "- Document your function well so other people know how to use it!"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}