Lesson 1. Working with Numbers, Variables, and Functions-Copy1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Working with Numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At its core, Python is a calculator. For example, we could use Python to solve $8 + 4$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "print( 8 + 4 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also solve $8 - 4$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "print( 8 - 4 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can solve $8 \\times 4$ using an *asterisk* (**\\***):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32\n"
     ]
    }
   ],
   "source": [
    "print( 8 * 4 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we can solve $8 \\div 4$ using a *forward slash* (**/**):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n"
     ]
    }
   ],
   "source": [
    "print( 8 / 4 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To solve $8^4$, we use two asterisks (**\\*\\***):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4096\n"
     ]
    }
   ],
   "source": [
    "print( 8 ** 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sidenote: Exponents"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$8^4$ is pronounced *\"$8$ to the power of $4$\"*. and is the same thing as $8 \\times 8 \\times 8 \\times 8$. Basically, you have $4$ copies of the number $8$, and you are multiplying them all together. This operation is called *exponentiation*. $8$ is the *base*, and $4$ is the *exponent*. Here are some more examples:\n",
    "\n",
    "$2^2 = 2 \\times 2 = 4$\n",
    "\n",
    "$3^3 = 3 \\times 3 \\times 3 = 27$\n",
    "\n",
    "$5^6 = 5 \\times 5 \\times 5 \\times 5 \\times 5  \\times 5 = 15625$\n",
    "\n",
    "You should also know that any number to the power of $1$ is itself, and any number to the power of $0$ is $1$.\n",
    "\n",
    "$1000000^1 = 1000000$\n",
    "\n",
    "$1000000^0 = 1$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Excercises\n",
    "Use Python to solve the following math problems:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1\\. $256 + 957$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2\\. $374 - 891$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3\\. $831 \\times 112$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4\\. $334 \\div 42$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "5\\. $32 ^ 6$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Order of Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is the solution to $4 + 12 \\div 4$? Let's use Python to find out:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.0\n"
     ]
    }
   ],
   "source": [
    "print( 4 + 12 / 4 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The answer is $7$. You might be wondering why the answer isn't $4$. After all, $4 + 12 = 16$ and $16 \\div 4 = 4$. But this is not the correct way to solve the problem because of the *order of operations*.\n",
    "\n",
    "According to the order of operations, you must solve problems using the following steps:\n",
    "\n",
    "1. First solve anything inside of parentheses, starting with the innermost parentheses and working outwards.\n",
    "2. Second, solve all exponentiation from left to right.\n",
    "3. Third, solve all multiplication and division from left to right.\n",
    "4. Finally, solve all addition and subtraction from left to right.\n",
    "\n",
    "Just remember \"PEMDAS\" for Parentheses (P), Exponents (E), Multiplication and Division (MD), and Addition and Subtraction (AS).\n",
    "\n",
    "Let's look at an example:\n",
    "\n",
    "$(9 - 5 \\div (8 - 3) \\times 2 + 6) + 3^2$\n",
    "\n",
    "First, we need to solve what's in the parentheses. There are two sets of parentheses in this problem. We need to start with the innermost ones, which contain $8 - 3$. The answer to $8 - 3$ is $5$, so we can rewrite the problem as\n",
    "\n",
    "$(9 - 5 \\div 5 \\times 2 + 6) + 3^2$\n",
    "\n",
    "Now we have to solve what's in the remaining set of parentheses. The order of operations tells us that we need to first solve the multiplication and division problems from left to right, so first we replace $5 \\div 5$ with $1$.\n",
    "\n",
    "$(9 - 1 \\times 2 + 6) + 3^2$\n",
    "\n",
    "Then we replace $1 \\times 2$ with $2$.\n",
    "\n",
    "$(9 - 2 + 6) + 3^2$\n",
    "\n",
    "Now we solve addition and subtraction problems from left to right, so we replace $9 - 2$ with $7$\n",
    "\n",
    "$(7 + 6) + 3^2$\n",
    "\n",
    "And we replace $7 + 6$ with $13$\n",
    "\n",
    "$13 + 3^2$\n",
    "\n",
    "Now we are just left with an addition and an exponentiation. First we solve $3^2$, which is 9\n",
    "\n",
    "$13 + 9$\n",
    "\n",
    "Finally, $13 + 9$ is $22$, and that is our final answer. We can check our work using Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22.0\n"
     ]
    }
   ],
   "source": [
    "print( (9 - 5 / (8 - 3) * 2 + 6) + 3**2 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Excercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Solve the following math problems using pencil and paper. Then use Python to check your work."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1\\. $5^2 + 3$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2\\. $3 + 6 \\times (5 + 4) \\div 3 - 7$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3\\. $150 \\div (6 + 3 \\times 8) - 5$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's consider the following problem:\n",
    "\n",
    "*Yoshi walks through the forest looking for fruit. He finds $5$ apples, $3$ oranges, $2$ bananas, and $8$ strawberries. How many pieces of fruit did Yoshi find in total?*\n",
    "\n",
    "To solve this problem, we just need to add up all the numbers of apples, oranges, bananas, and strawberries. This is very easy to do in Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18\n"
     ]
    }
   ],
   "source": [
    "print( 5 + 3 + 2 + 8 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This code gives us the correct answer, but if you turned off your computer for the night and came back the next day, you probably wouldn't remember what problem it was supposed to solve. There's nothing in this code that tells you what any of the numbers mean! To help with this issue, we can give these numbers names by creating *variables*. A variable is a value that has a name attached to it. To create a variable in Python, type the name of the variable, an equals sign (**=**), and the value of the variable, like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "number_of_apples = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now have a variable called \"number_of_apples\" which corresponds to the number of apples that Yoshi found. This is called *variable assignment* If we forget what the value of this variable is, we can just run the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "print( number_of_apples )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also do math with our variable as if it were just a normal number:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "print( number_of_apples + 1 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "print( number_of_apples * 2 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.0\n"
     ]
    }
   ],
   "source": [
    "print( (number_of_apples ** 2 + 5) / 6 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that you must always refer to a variable using its **exact** name. Any typos will cause Python to give you an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'number_of_apple' 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<ipython-input-14-4a79324c9e8d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m \u001b[0mnumber_of_apple\u001b[0m \u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'number_of_apple' is not defined"
     ]
    }
   ],
   "source": [
    "print( number_of_apple )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'Number_Of_Apples' 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<ipython-input-15-e4c376618b9f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m \u001b[0mNumber_Of_Apples\u001b[0m \u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'Number_Of_Apples' is not defined"
     ]
    }
   ],
   "source": [
    "print( Number_Of_Apples )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also note that Python will give you an error if you try to get the value of a variable that you haven't created:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'number_of_peaches' 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<ipython-input-16-8386101153a8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m \u001b[0mnumber_of_peaches\u001b[0m \u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'number_of_peaches' is not defined"
     ]
    }
   ],
   "source": [
    "print( number_of_peaches )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's make some variables corresponding to the other fruits that Yoshi found:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "number_of_oranges = 3\n",
    "number_of_bananas = 2\n",
    "number_of_strawberries = 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's create one more variable that represents the total number of fruits that Yoshi found:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "total_number_of_fruits = number_of_apples + number_of_oranges + number_of_bananas + number_of_strawberries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that you can create a variable from other variables! Now to get the final answer to the problem, we can just print the value of total_number_of_fruits:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18\n"
     ]
    }
   ],
   "source": [
    "print( total_number_of_fruits )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It should be pointed out that there is nothing special about the names of the variables we created. We could have named our variables single letters like 'x', 'y', or 'z', or nonsense words like 'foo' and 'baz'. But remember that part of the reason for creating variables is to help you understand what your code is doing, so make sure you always use helpful variable names!\n",
    "\n",
    "There are some names that Python absolutely won't allow you to use. For example, if you try to name a variable with just a number, Python will give you an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "can't assign to literal (<ipython-input-20-6b36426d02b5>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-20-6b36426d02b5>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    10 = 5\u001b[0m\n\u001b[0m          ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m can't assign to literal\n"
     ]
    }
   ],
   "source": [
    "10 = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are two main rules to follow when giving variables names:\n",
    "1. Variable names must always start with a letter or an underscore (_).\n",
    "2. The rest of the name must consist of only letters, numbers, and underscores.\n",
    "\n",
    "These are all acceptable variable names:\n",
    "- PYTHON\n",
    "- _underscore\n",
    "- password1\n",
    "- n00b\n",
    "\n",
    "These are **not** acceptable variable names:\n",
    "- 12345\n",
    "- number of apples\n",
    "- (^_^)\n",
    "- number+of+apples\n",
    "\n",
    "There are also some special *keywords* that Python will not let you use as variable names: 'False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', and 'yield'.\n",
    "\n",
    "We'll talk about what some of these keywords are used for in later lessons.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Excercise\n",
    "\n",
    "Use Python to solve the following problem. Make sure you use variables with helpful names.\n",
    "\n",
    "*Mario has $100$ coins. He spends $25$ coins on a new hat, and then he spends $47$ coins on a new pair of overalls. Then he finds $12$ coins inside a block. How many coins does Mario have now?*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Manipulating Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the cool things about variables is that we can change them. Recall that our variable \"number_of_apples\" was equal to $5$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "print( number_of_apples )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can assign it to a different number if we want:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "number_of_apples = 7\n",
    "print( number_of_apples )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or we can assign it to the value of a formula:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "number_of_apples = number_of_bananas * 2\n",
    "print( number_of_apples )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's say that Yoshi starts out with five apples, and then he finds two more. We can represent this scenario in Python code like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "number_of_apples = 5\n",
    "number_of_apples = number_of_apples + 2\n",
    "print(number_of_apples)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It might look strange to have the same variable on both sides of the equals sign, but here's what is going on: Python first sees \"number_of_apples =\", so it knows that you want to assign the variable \"number_of_apples\" to some sort of value, and it looks to the right of the equals sign to figure out what that value is. It sees \"number_of_apples + 2\". It knows that \"number_of_apples\" is $5$, and $5 + 2 = 7$, so the new value of \"number_of_apples\" is 7.\n",
    "\n",
    "Something you should keep in mind is that when you assign variable1 equal to variable2, the value of variable1 will be equal to the value that variable2 was at the time of assignment, even if the value of variable2 changes later. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "variable2 = 10\n",
    "variable1 = variable2\n",
    "variable2 = 5\n",
    "print(variable1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Excercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try to guess what the value of the variable 'x' will be after running the following Python code. Then actually run the code to check your answer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 6\n",
    "y = 3\n",
    "x = x - y + 1\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 12\n",
    "y = 4\n",
    "x = x / y\n",
    "y = 3\n",
    "x = x / y\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use Python to solve the following problem. Make sure you use variables with helpful names, and change the values of the variable when necessary.\n",
    "\n",
    "*Yoshi walks through the forest looking for fruit. He finds $6$ apples, but he discovers that $2$ of them are rotten, so he throws them away. Then he finds $8$ oranges and $3$ strawberries. Later on, he finds $4$ strawberries and $2$ bananas. On his way home, he drops $2$ of the oranges, and $1$ of the strawberries. How many of each type of fruit does Yoshi have? How many fruits does Yoshi have total?*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pretend that you own a restaurant, and you want to calculate how much money you are earning. You earn money from selling food, but you also lose money from buying supplies and paying your employees. Let's say that one day your earn $\\$3224.45$ from sales, and you lose $\\$457.21$ from buying supplies and $\\$699.53$ from paying your employees. We can calculate your *net profit* in Python like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2067.71\n"
     ]
    }
   ],
   "source": [
    "sales = 3224.45\n",
    "supplies = 457.21\n",
    "employees = 699.53\n",
    "profit = sales - supplies - employees\n",
    "print(profit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OK, so you earned $\\$2067.71$ that day! On the next day you earn $\\$3658.11$ from sales, you lose $\\$255.66$ from buying supplies, and $\\$634.95$ from paying your employees. We can write some more Python code to calculate the profit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2767.5\n"
     ]
    }
   ],
   "source": [
    "sales = 3658.11\n",
    "supplies = 255.66\n",
    "employees = 634.95\n",
    "profit = sales - supplies - employees\n",
    "print(profit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On that day you earned  $\\$2767.50$! On the next day you earn  $\\$2984.70$ from sales, you lose  $\\$300.04$ from buying supplies, and  $\\$702.62$  from paying your employees. Again, we can write some more Python code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1982.04\n"
     ]
    }
   ],
   "source": [
    "sales = 2984.70\n",
    "supplies = 300.04\n",
    "employees = 702.62\n",
    "profit = sales - supplies - employees\n",
    "print(profit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So on that day you earned $\\$1982.04$. It's getting kind of annoying to keep writing this code over and over again, isn't it? It's basically the same code every time, just different numbers. This is a case where you would want to create a *function*. A function allows you to run the same code over and over again without having to type it out every time. Let's look at an example of a *function definition*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def calculate_profit(sales, supplies, employees):\n",
    "    profit = sales - supplies - employees\n",
    "    return profit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you create a function, you have to use the keyword \"def\" which is short for define. Then you put the name of the function and the function's *arguments* in parentheses. The arguments are the variables that change each time you run the function. In this case, our arguments are the money earned from sales, and the money lost from supplies and employees. Then you put a colon (**:**), and underneath that you put the *body* of the function. The body is the code that you want to run over and over again. In this case, we want to calculate the net profit from sales, supplies, and employees. The *return statement* at the end of the body tells Python what you want the final answer of the function to be. In this case, we want the final answer to be the net profit. Notice that the body must be indented. The indendation tells python where the body of the function starts and ends, and it makes the code easier for you to read."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's use our function. To use it, we type out the function's name, and then put the arguments in parentheses. We have to put our arguments in the same order that we put them in the function definition. So in this case we put \"calculate_profit(sales, supplies, employees):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2067.71\n",
      "2767.5\n",
      "1982.04\n"
     ]
    }
   ],
   "source": [
    "day1_profit = calculate_profit(3224.45, 457.21, 699.53)\n",
    "day2_profit = calculate_profit(3658.11, 255.66, 634.95)\n",
    "day3_profit = calculate_profit(2984.70, 300.04, 702.62)\n",
    "\n",
    "print(day1_profit)\n",
    "print(day2_profit)\n",
    "print(day3_profit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We got the same answers, and we didn't have to write the same code a bunch of times! This will be very useful if we want to keep doing these same calculations every day.\n",
    "\n",
    "### Sidenote: Comments\n",
    "Earlier, it was mentioned that you can help yourself remember what your code is doing by creating helpful variable names. You can also leave helpful messages for yourself inside of your code by using *comments*. You can add a comment for yourself using the number sign (**#**) like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def calculate_profit(sales, supplies, employees):\n",
    "    #This function calculates net profit from sales, supply expenses, and exmployee expenses.\n",
    "    profit = sales - supplies - employees\n",
    "    return profit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's a good idea to write a comment explaining what your all functions do because you might not remember if you don't look at your code for a while. It's also a good idea to leave a comment wherever your code gets really complicated or confusing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Excercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What will Python print out when the following code is run? Try to figure it out with pencil and paper first, and then actually run the code to check your work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "calculate_profit(4562.00, 555.25, 705.90)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a function that takes two arguments, $x$ and $y$, and returns $x^2 + y^2$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suppose again that you own a restaurant, and there is another variable that makes you lose money: your electricity bill. Modify the function \"calculate_profit\" to take this variable into account."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}