python_2.1_functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python: Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Required Reading\n",
    "1. [Functions](https://www.py4e.com/html3/04-functions) from Python for Everybody by Charles Severance. Supplementary videos are [available here](https://www.py4e.com/lessons/functions).\n",
    "2. [Functions](https://automatetheboringstuff.com/chapter3/) from Automate the Boring Stuff by Al Sweigart. There are links to videos within the text in case those are helpful for your understanding. Pay particular attention to the discussion of local and global scope, as this is a key concept in programming."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section, we'll be covering how functions work, how you can use them, and how to create your own.\n",
    "\n",
    "A function, as you've read, has a few components. It may (or may not) have input arguments and it may (or may not) have outputs. Here's an example of a function that has both inputs and returns an output that represents the exponentiation function $f(x,y) = x^y$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "def exponent(x,y):\n",
    "    return x**y\n",
    "\n",
    "print(exponent(3,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But, a function may not take arguments or return output, it might just do something:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "supercalifragilisticexpialidocious\n"
     ]
    }
   ],
   "source": [
    "def sillyfunction():\n",
    "    print('supercalifragilisticexpialidocious')\n",
    "    \n",
    "sillyfunction()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course you can put all of the machinery we've discussed so far inside of functions - conditionals (i.e., `if` statements), loops, etc. \n",
    "\n",
    "### Don't Repeat Yourself (DRY)\n",
    "So an important question comes up: when should something just be a few lines of code in a script, and when should it be a defined function? The answer to this question comes from reuse. If you'll need that set of code again (or find yourself copying and pasting it to another part of a script), then it's time for a function. This makes things a lot simpler. Imagine if you have copied and pasted 3 lines of code to 10 different places in scripts that you have written. Then you realize that you need to make a change to one of those lines of code. That would mean making the change 10 times. If, instead, you've written a function that incorporates those 3 lines of code, and have *called* the function 10 times, then all you'd need to do is to change the function itself once to implement the change in all the 10 locations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise\n",
    "As I recommend throughout this class - make sure you have Spyder open and go ahead and work through this along with the explanation. In fact, I'd recommend reading the problem description below and trying to solve the problem on your own before going through the solution."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Working with data using functions  \n",
    "*Problem from [Project Euler](https://projecteuler.net/)*\n",
    "\n",
    "We often have to identify subsets of data that meet certain conditions for analyses. This process is sometimes referred to as filtering. We can filter data to remove values below a certain threshold or we can remove values we believe may be erroneous sensor readings. This problem is in that spirit, except with finding numbers that are multiples of other numbers.\n",
    "\n",
    "If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.\n",
    "\n",
    "Our goal is to find the sum of all the multiples of 3 or 5 below 1000.\n",
    "\n",
    "First we need a function that determines whether a number is a multiple of another number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Determine if one number is a multiple of another\n",
    "def ismultiple(multiple,number):\n",
    "    if multiple % number == 0:\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check to make sure this function works"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ismultiple(10,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ismultiple(10,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could create a script that answers the specific function for multiples of 3 and 5 and sums the numbers below 1000:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "233168\n"
     ]
    }
   ],
   "source": [
    "multiples_sum = 0  # Initialize a counter to zero\n",
    "for n in range(1000):\n",
    "    # Check if it's a multiple of 3 or 5\n",
    "    if ismultiple(n,3) or ismultiple(n,5):\n",
    "        multiples_sum = multiples_sum + n\n",
    "\n",
    "print(multiples_sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But at this point, we have no idea whether or not this is correct. Did we code it right or is there a bug in our code? What would be better is if we could test whether this works for some examples that we know about. But in its current form this script requires us to change one of the hard-coded parameters in the `range()` function in the `for` loop. Let's go ahead and make this into a function that takes a parameter instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "233168\n"
     ]
    }
   ],
   "source": [
    "def sum_multiples_35(max_value):\n",
    "    multiples_sum = 0  # Initialize a counter to zero\n",
    "    for n in range(max_value):\n",
    "        # Check if it's a multiple of 3 or 5\n",
    "        if ismultiple(n,3) or ismultiple(n,5):\n",
    "            multiples_sum = multiples_sum + n\n",
    "    return multiples_sum\n",
    "\n",
    "print(sum_multiples_35(1000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This gives us the same value, so that's good. Let's check to see if another known value works - we were told in the problem statement that for all of the numbers below 10, that the sum of multiples of 3 and 5 is 23. Let's test this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23\n"
     ]
    }
   ],
   "source": [
    "print(sum_multiples_35(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Excellent! So far, so good!\n",
    "\n",
    "Now let's say we were so excited to find that number, that we wanted to know the sum of all multiples of 3, 5, or 7 below 1500. Well, we COULD hard code into our function this new ability:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "611029\n"
     ]
    }
   ],
   "source": [
    "def sum_multiples_357(max_value):\n",
    "    multiples_sum = 0  # Initialize a counter to zero\n",
    "    for n in range(max_value):\n",
    "        # Check if it's a multiple of 3, 5, or 7\n",
    "        if ismultiple(n,3) or ismultiple(n,5) or ismultiple(n,7):\n",
    "            multiples_sum = multiples_sum + n\n",
    "    return multiples_sum\n",
    "\n",
    "print(sum_multiples_357(1500))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Problem solved! But what if we got new requests for this every day? It would be a pain to keep updating this function and will lead to a lot of copying and pasting of code and confusingly similar functions like `sum_multiples_35()` vs `sum_multiples_357()`. Whenever you start copying and pasting code to make minor changes, this should raise a major red flag. We want to follow the adage: Don't Repeat Yourself (DIY). There is a way to do that here: let's make a function that takes as a parameter a list of numbers that are possible multiples.\n",
    "\n",
    "Let's start by creating a helper function that takes as input a list of multiples and a number and checks whether or not any of those multiples are actually multiples of the input number. *Note: Here we can use our handy list comprehension, but we could also have built a for loop instead that did the trick*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def anymultiples(n,multiples_to_test):\n",
    "    # First test to see which values are actually multiples\n",
    "    is_a_multiple = [ismultiple(n,value) for value in multiples_to_test]\n",
    "    \n",
    "    # Now see if any the values are multiples\n",
    "    return any(is_a_multiple)\n",
    "\n",
    "# Let's test it\n",
    "print(anymultiples(14,[3,5]))\n",
    "print(anymultiples(14,[3,5,7]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's bring it all together into our more general `sum_multiples()` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def sum_multiples(max_value, multiples_to_test):\n",
    "    multiples_sum = 0  # Initialize a counter to zero\n",
    "    for n in range(max_value):\n",
    "        # Check if it's a multiple of 3, 5, or 7\n",
    "        if anymultiples(n,multiples_to_test):\n",
    "            multiples_sum = multiples_sum + n\n",
    "    return multiples_sum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, this should work on all of our previous test cases:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23\n",
      "233168\n"
     ]
    }
   ],
   "source": [
    "print(sum_multiples(10, [3,5]))\n",
    "print(sum_multiples(1000, [3,5]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great - now that we've checked that, let's go ahead and calculate the sum of all multiples of 3, 5, or 7 below 1500:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "611029\n"
     ]
    }
   ],
   "source": [
    "print(sum_multiples(1500, [3,5,7]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we have a general purpose algorithm that can be used to check for and sum any number of multiples we'd like, and we did it in a way that we didn't repeat ourselves."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Next\n",
    "Often we need many functions in a given project. How do we keep track of manage lots of functions? In the next section, we'll discuss how to combine related groups of functions into packages and modules and what distinguishes them from scripts."
   ]
  }
 ],
 "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}