This is a guest lecture for sections 1/2. Section 4, we have already covered this material (but another viewing might not be a bad idea!)

Functions

Functions are a key -- perhaps the key python formalism. Functions allow us to :

Break our programs into smaller, more manageable chunks
Make our code more readable, and easier to understand
Allow for code reuse -- reusing part of our code in different programs

We've already seen some functions: print and input functions (and, technically all arithmetic operations: +, -, *, **, etc). We will see many more library functions as we go on in the class, and we will also write several of our own functions. In fact, Python programming is almost entirely writing functions -- it is what we will spend the rest of the class doing!

Writing Functions

Functions have the following syntax:

def function_name(paramlist):
    functionbody

where:

def is a keyword that lets python know that you are about to define a function
function_name is the name of the function. This name must not be one of python's reserved words
paramlist is a list of zero or more parameters, separated by commas
The colon : is required!
functionbody is a list of statements, each indented by 4 spaces (just like while loop bodies!) If the function returns a value, then the function body must have a return statement

For example, consider the (very simple!) function:

def add2(a,b):
    return a + b

add2 visualization

This function adds two numbers. If we saved this function in the file add2, we could first import all of the functions from this file, and then use it:

>>> from add2 import *  ## or just Run Module from idle
>>> add2(3,4)
7
>>> x = add2(5,6)
>>> print(x)
11

Let's take a closer look at what happens when we execute a function call, like add2(3,4):

First, evaluate the values of the parameters -- in this case the expressions 3 and 4
Next create variables local to the function (we can only see them locally in the function!) for the parameters (in this case a and b) and copy in the appropriate values
Execute each statement in the body
When you get to a return statement:
- Evaluate the expression -- this will be the return value of the function
- STOP! It does not matter if there are other statements that follow the return statement, stop IMMEDIATELY
- DESTROY ALL THE SPACE ALLOCATED FOR THE FUNCTION
- Return the result of the function

Looking at more examples:

def absValue(n):
    if (n >= 0):
        return n
    else:
        return 0-n

def absValue2(n):
    if (n >= 0):
        return n
    return 0-n

Visualization of absValue / absValue2

Note that both absValue and absValue2 compute the same thing. Why?

def power(base, exponent):
    result = 1
    while exponent > 0:
        result = result * base
        exponent = exponent - 1
    return result

Power visualization

Some things to note:

Functions have their own space for parameters and local variables
- Parameters are only defined for the life of the function
- If we define a new variable inside a function (like result above), then that variable can only be used inside the function
- If we define a new variable inside a function, and there was already another variable with the same name that's OK!. The function will use its own local variable, and leave the other one alone
Every variable you use in a function should either be:
- A parameter to the function
- Defined before it is used

In-Class Exercises

Time to get your fingers dirty! Please complete as many of the following exercises as you can in-class. I do not expect all of you (or really, any of you to finish all of them! (I do want to make sure that no one is bored because they finished everything before the end of class and had nothing to do! These exercises are not for credit, and will not be turned it (the skills you get from completing them, however, will help you do better on exams / projects / etc!

Write the following functions
1. maxVal(a,b): returns the maximum value of a and b
```
>>> maxVal(3,5)
5
>>> maxVal(11,2)
11
>>> maxVal(5, 10)
10
```
2. maxOfThree(a,b,c): returns the maximum value of a and b and c
```
>>> maxOfThree(3,5,11)
11
>>> maxOfThree(10,3,5)
10
>>> maxOfThree(3,11,2)
11
```
  Once maxOfThree works, rewrite it so that maxOfThree Does not use an if statement, but instead only uses calls maxVal
3. factorial(n): returns n! Recall that n! = 1 * 2 * 3 * 4 * ... * n
```
>>> factorial(3)
6
>>> factorial(5)
120
>>> factorial(10)
3628800
```

Give the output of the following functions. Check your answers with the visualization

def square(n):
    return n * n

def sumOfSquares(a,b):
    return square(a) + square(b)
    

print(sumOfSquares(3,4))

visualization

def f(a):
    x = 3
    print("in f, a = ", a, " x = ", x)
    return a + 1


def g(a):
    x = 4
    print("in g, a = ",a, "x = ", x)
    return a + 2

x = f(2)
print("in main, x = ", x)
x = g(x)
print("in main, x = ", x)
x = f(x)
print("in main, x = ", x)

visualization

def whatDoIDo(a, b):
    c = 0
    while (a > 0):
        c = c + b
        a = a - 1
    return c
    

x = whatDoIDo(0, 3)
print(x)
x = whatDoIDo(2,2)
print(x)
x = whatDoIDo(3,5)
print(x)
x = whatDoIDo(5,3)
print(x)
x = whatDoIDo(10,10)
print(x)
x = whatDoIDo(10,0)
print(x)

visualization

Write the following functions (I'd be thrilled if anyone got this far!)
1. dividesEvenly. Takes as input 2 parameters, and returns True if the first number can be divided evenly by the second number
```
>>> dividesEvenly(10,2)
True
>>> dividesEvenly(10,3)
False
>>> dividesEvenly(10,4)
False
>>> dividesEvenly(10,5)
True
>>> dividesEvenly(10,6)
False
```
  Note that x divides evenly by y if and only if the remainder when you divide x by y is zero -- that is, x % y == 0
2. prime. Takes as input a single parameter, and returns True if that parameter is prime. You will want to use dividesEvenly and a while loop for this one! (advanced)
```
>>> prime(2)
True
>>> prime(3)
True
>>> prime(4)
False
>>> prime(5)
True
>>> prime(6)
False
>>> prime(10)
False
>>> prime(13)
True
>>> prime(137)
True
>>> prime(153)
False
```