from __future__ import division, print_function a = 23 b = -23 if a < 0: a = -a if b < 0: b = -b if a == b: print("The absolute values of", a, "and", b, "are equal") else: print("The absolute values of a and b are different")with the output being:

The absolute values of 23 and 23 are equalThe program seems a little repetitive. (Programmers hate to repeat things (That's what computers are for aren't they?)) Fortunately Python allows you to create functions to remove duplication. Here's the rewritten example:

from __future__ import division, print_function a = 23 b = -23 def my_abs(num): if num < 0: num = -num return num if my_abs(a) == my_abs(b): print("The absolute values of", a, "and", b, "are equal") else: print("The absolute values of a and b are different")with the output being:

The absolute values of 23 and -23 are equalThe key feature of this program is the

Notice how the values of `a` and `b` are not changed.
Functions of course can be used to repeat tasks that don't return
values. Here's some examples:

from __future__ import division, print_function def hello(): print("Hello") def area(width, height): return width*height def print_welcome(name): print("Welcome", name) hello() hello() print_welcome("Fred") w = 4 h = 5 print("width =", w, "height =", h, "area =", area(w, h))with output being:

Hello Hello Welcome Fred width = 4 height = 5 area = 20That example just shows some more stuff that you can do with functions. Notice that you can use no arguments or two or more. Notice also when a function doesn't need to send back a value, a return is optional.

Of course, when eliminiating repeated code, you often have variables in the repeated code. These are dealt with in a special way in Python. Up till now, all variables we have see are global variables. Functions have a special type of variable called local variables. These variables only exist while the function is running. When a local variable has the same name as another variable such as a global variable, the local variable hides the other variable. Sound confusing? Well, hopefully this next example (which is a bit contrived) will clear things up.

from __future__ import division, print_function a_var = 10 b_var = 15 e_var = 25 def a_func(a_var): print("in a_func a_var = ", a_var) b_var = 100 + a_var d_var = 2*a_var print("in a_func b_var = ", b_var) print("in a_func d_var = ", d_var) print("in a_func e_var = ", e_var) return b_var + 10 c_var = a_func(b_var) print("a_var = ", a_var) print("b_var = ", b_var) print("c_var = ", c_var) print("d_var = ", d_var)

The output is:

in a_func a_var = 15 in a_func b_var = 115 in a_func d_var = 30 in a_func e_var = 25 a_var = 10 b_var = 15 c_var = 125 Traceback (most recent call last): File "varfunc.py", line 20, in <module> print("d_var = ", d_var) NameError: name 'd_var' is not defined

In this example the variables `a_var`, `b_var`, and `d_var`
are all local variables when they are inside the function `a_func`.
After the statement `return b_var + 10` is run, they all cease to
exist. The variable `a_var` is automatically a local variable since it
is a parameter name. The variables `b_var` and `d_var` are local
variables since they appear on the left of an equals sign in the function in
the statements `b_var = 100 + a_var`

and `d_var = 2*a_var`

.

Inside of the function `a_var` is 15 since the function is called
with `a_func(b_var)`. Since at that point in time `b_var` is
15, the call to the function is `a_func(15)` This ends up setting
`a_var` to 15 when it is inside of `a_func`.

As you can see, once the function finishes running, the local variables
`a_var` and `b_var` that had hidden the global variables of the same
name are gone. Then the statement `print("a_var = ", a_var)`

prints the
value `10` rather than the value `15` since the local variable
that hid the global variable is gone.

Another thing to notice is the `NameError` that happens at the end.
This appears since the variable `d_var` no longer exists since
`a_func` finished. All the local variables are deleted when the function
exits. If you want to get `something` from a function, then you will have
to use `return something`.

One last thing to notice is that the value of `e_var` remains unchanged
inside `a_func` since it is not a parameter and it never appears on the
left of an equals sign inside of the function `a_func`. When a
global variable is accessed inside a function it is the global variable
from the outside.

Functions allow local variables that exist only inside the function and can hide other variables that are outside the function.

Now we will do a walk through for the following program:

from __future__ import division, print_function def mult(a, b): if b == 0: return 0 rest = mult(a, b - 1) value = a + rest return value print("3*2 = ", mult(3, 2))

Basically this program creates a positive integer multiplication function (that is far slower than the built in multiplication function) and then demonstrates this function with a use of the function. Some people find this section helpful, others find it confusing. If it gets confusing, you can skip it.

**Question: **What is the first thing the program does?

**Answer: **After the magic lines, the first thing done is the function `mult` is defined with the lines:

def mult(a, b): if b == 0: return 0 rest = mult(a, b - 1) value = a + rest return valueThis creates a function that takes two parameters and returns a value when it is done. Later this function can be run.

**Question: **What happens next?

**Answer: **The next line after the function,
`print("3*2 = ", mult(3, 2))`

is run.

**Question: **And what does this do?

**Answer: **It prints `3*2 = `

and the return value of `mult(3, 2)`

**Question: **And what does `mult(3, 2)`

return?

**Answer: **We need to do a walkthrough of the `mult` function to find out.

**Question: **What happens next?

**Answer: **The variable `a` gets the value 3 assigned to it and the
variable `b` gets the value 2 assigned to it.

**Question: **And then?

**Answer: **The line `if b == 0:`

is run. Since `b` has the value 2
this is false so the line ` return 0`

is skipped.

**Question: **And what then?

**Answer: **The line `rest = mult(a, b - 1)`

is run. This line sets the
local variable `rest` to the value of `mult(a, b - 1)`

. The
value of `a` is 3 and the value of `b` is 2 so the function call
is `mult(3, 1)`

**Question: **So what is the value of `mult(3, 1)`

?

**Answer: **We will need to run the function `mult` with the parameters
3 and 1.

**Question: **So what happens next?

**Answer: **The local variables in the *new* run of the function are
set so that `a` has the value 3 and `b` has the value 1.
Since these are local values these do not affect the previous values
of `a` and `b`.

**Question: **And then?

**Answer: **Since `b` has the value 1 the if statement is false, so the
next line becomes `rest = mult(a, b - 1)`

.

**Question: **What does this line do?

**Answer: **This line will assign the value of `mult(3, 0)` to rest.

**Question: **So what is that value?

**Answer: **We will have to run the function one more time to find that out.
This time `a` has the value 3 and `b` has the value 0.

**Question: **So what happens next?

**Answer: **The first line in the function to run is `if b == 0:`

. `b` has the value 0 so the next line to run is `return 0`

**Question: **And what does the line `return 0`

do?

**Answer: **This line returns the value 0 out of the function.

**Question: **So?

**Answer: **So now we know that `mult(3, 0)` has the value 0. Now we
know what the line `rest = mult(a, b - 1)`

did since we have run
the function `mult` with the parameters 3 and 0. We have finished
running `mult(3, 0)` and are now back to running `mult(3, 1)`.
The variable `rest` gets assigned the value 0.

**Question: **What line is run next?

**Answer: **The line `value = a + rest`

is run next. In this run of the
function, `a=3`

and `rest=0`

so now `value=3`

.

**Question: **What happens next?

**Answer: **The line `return value`

is run. This returns 3 from the function.
This also exits from the run of the function `mult(3, 1)`. After `return` is called, we go back to running `mult(3, 2)`.

**Question: **Where were we in `mult(3, 2)`?

**Answer: **We had the variables `a=3`

and `b=2`

and were examining
the line `rest = mult(a, b - 1)`

.

**Question: **So what happens now?

**Answer: **The variable `rest` get 3 assigned to it. The next line
`value = a + rest`

sets `value` to `3+3` or 6.

**Question: **So now what happens?

**Answer: **The next line runs, this returns 6 from the function. We are now
back to running the line `print("3*2 = ", mult(3, 2))`

which can now
print out the 6.

**Question: **What is happening overall?

**Answer: **Basically we used two facts to calulate the multipule of the
two numbers. The first is that any number times 0 is 0 (`x * 0 =
0`). The second is that a number times another number is equal to the
first number plus the first number times one less than the second
number (`x * y = x + x * (y - 1)`). So what happens is `3*2` is
first converted into `3 + 3*1`. Then `3*1` is converted into
`3 + 3*0`. Then we know that any number times 0 is 0 so `3*0`
is 0. Then we can calculate that `3 + 3*0` is `3 + 0` which
is `3`. Now we know what `3*1` is so we can calculate that
`3 + 3*1` is `3 + 3` which is `6`.

This is how the whole thing works:

3*2 3 + 3*1 3 + 3 + 3*0 3 + 3 + 0 3 + 3 6

Congratulations, you stepped through a complicated function.

factorial.py

from __future__ import division, print_function #defines a function that calculates the factorial def factorial(n): if n <= 1: return 1 return n*factorial(n-1) print("2! = ", factorial(2)) print("3! = ", factorial(3)) print("4! = ", factorial(4)) print("5! = ", factorial(5))

Output:

2! = 2 3! = 6 4! = 24 5! = 120

temperature2.py

from __future__ import division, print_function import sys if sys.version_info.major == 2: input = raw_input #converts temperature to fahrenheit or celsius def print_options(): print("Options:") print(" 'p' print options") print(" 'c' convert from celsius") print(" 'f' convert from fahrenheit") print(" 'q' quit the program") def celsius_to_fahrenheit(c_temp): return 9.0/5.0*c_temp+32 def fahrenheit_to_celsius(f_temp): return (f_temp - 32.0)*5.0/9.0 choice = "p" while choice != "q": if choice == "c": temp = float(input("Celsius temperature:")) print("Fahrenheit:", repr(celsius_to_fahrenheit(temp))) elif choice == "f": temp = float(input("Fahrenheit temperature:")) print("Celsius:", repr(fahrenheit_to_celsius(temp))) elif choice != "q": print_options() choice = input("option:")

Sample Run:

> python temperature2.py Options: 'p' print options 'c' convert from celsius 'f' convert from fahrenheit 'q' quit the program option:c Celsius temperature:30 Fahrenheit: 86.0 option:f Fahrenheit temperature:60 Celsius: 15.5555555556 option:q

area2.py

from __future__ import division, print_function import sys if sys.version_info.major == 2: input = raw_input #By Amos Satterlee print() def hello(): print('Hello!') def area(width, height): return width*height def print_welcome(name): print('Welcome,', name) name = input('Your Name: ') hello() print_welcome(name) print() print('To find the area of a rectangle,') print('Enter the width and height below.') print() w = float(input('Width: ')) while w <= 0: print('Must be a positive number') w = float(input('Width: ')) h = float(input('Height: ')) while h <= 0: print('Must be a positive number') h = float(input('Height: ')) print('Width =', w, ' Height =', h, ' so Area =', area(w, h))

Sample Run:

Your Name: Josh Hello! Welcome, Josh To find the area of a rectangle, Enter the width and height below. Width: -4 Must be a positive number Width: 4 Height: 3 Width = 4.0 Height = 3.0 so Area = 12.0

Rewrite the area.py program done in 3.2 to have a separate function for the area of a square, the area of a rectangle, and the area of a circle. (3.14 * radius**2). This program should include a menu interface.