# Functions

Sue Evans & James MacGlashan

Adapted from the CS1 Course at Swarthmore College by Lisa Meeden

Hit the space bar for next slide

# Learning Outcomes

• Understand why programmers divide programs up into sets of cooperating functions.
• Have the ability to define new functions in Python.
• Understand the details of function calls and parameter passing.
• Understand the distinction between functions, procedures and predicate functions.

# What are functions ?

• Functions define segments of code, similar to a subprogram
• Functions can be called at any time in a program
• Functions are generally useful when you need to repeatedly use a segment of code
• Functions in programming are analogous to functions in math such as f(x) = 2x
• We have actually used functions previously from the Python Modules such as math.sqrt(x)
• In this case sqrt is the name of a function defined in the math module

# A Song-singing Program

Let's write a program that "sings" Old MacDonald's Farm

```# Filename:   farm1.py
# Written by: Sue Evans
# Date:       7/31/09
# Section:    All
# Email:      bogar@cs.umbc.edu
#
# This program "sings" Old MacDonald's Farm

def main():

print "Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!"
print "And on that farm he had a cow, Ee-igh, Ee-igh, Oh!"
print "With a moo, moo here and a moo, moo there."
print "Here a moo, there a moo, everywhere a moo, moo."
print "Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!"

main()
```

Let's see if it works

```linuxserver1.cs.umbc.edu[117] python farm1.py
Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!
And on that farm he had a cow, Ee-igh, Ee-igh, Oh!
With a moo, moo here and a moo, moo there.
Here a moo, there a moo, everywhere a moo, moo.
Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!
linuxserver1.cs.umbc.edu[118]
```

Of course it works. There was nothing difficult about writing this code, except I got tired of typing "Ee-igh, Ee-igh, Oh!" So whenever you find yourself typing the same code over and over again, you should make a module out of that code by putting it in a function.

# Defining a function

• Functions are defined using the following form
• ```def <function-name>(<parameters>):
<block>
```
• def is a keyword that tells the system you are about to define a function.
• The <function-name> is a name of your choosing and must be different than any other functions you've defined.
• All function names are followed with parentheses. Inside the parentheses are the names of the variable parameters, if there are any (to be discussed later).
• Using the same format as if statements discussed earlier, we then use the colon, : and then the tab-indented notation to specify the code block of the function.
• The code block is the code that will be executed when a function is called.
• The first line of a function, i.e.
def <function-name>(<parameters>):
is known as the function header and the block of code beneath it is known as the function body.
• Below we've defined a function named chorus that prints the text, "Ee-igh, Ee-igh, Oh!"
• ```def chorus():
print "Ee-igh, Ee-igh, Oh!"
```

# Calling a function

• In order to call the function and execute its code, all we do is type the function name followed by the parentheses.
• We can call a function as many times as we want.
• Let's rewrite the song using our new function
• ```# Filename:   farm2.py
# Written by: Sue Evans
# Date:       7/31/09
# Section:    All
# Email:      bogar@cs.umbc.edu
#
# This program "sings" Old MacDonald's Farm
# making use of the chorus() function.

# chorus() prints the chorus of Old MacDonald's farm
# Inputs: none
# Outputs: none
def chorus():
print "Ee-igh, Ee-igh, Oh!"

def main():

print "Old MacDonald had a farm,",
chorus()
print "And on that farm he had a cow,",
chorus()
print "With a moo, moo here and a moo, moo there."
print "Here a moo, there a moo, everywhere a moo, moo."
print "Old MacDonald had a farm,",
chorus()

main()

```
• Does it work correctly ?
```linuxserver1.cs.umbc.edu[120] python farm2.py
Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!
And on that farm he had a cow, Ee-igh, Ee-igh, Oh!
With a moo, moo here and a moo, moo there.
Here a moo, there a moo, everywhere a moo, moo.
Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!
linuxserver1.cs.umbc.edu[121]
```

# Functions That Call Other Functions

We can also define functions that call other functions. Since our song has a repeated line at the beginning and end of the verse, let's write a function called line(). Since the end of the line is "Ee-igh, Ee-igh, Oh!", we'll be calling the function chorus() to do that. Our program now looks like this :

```# Filename:   farm3.py
# Written by: Sue Evans
# Date:       7/31/09
# Section:    All
# Email:      bogar@cs.umbc.edu
#
# This program "sings" one verse of Old MacDonald's Farm
# making use of the chorus() and line() functions.

# chorus() prints the chorus of Old MacDonald's farm
# Inputs: none
# Outputs: none
def chorus():
print "Ee-igh, Ee-igh, Oh!"

# line() prints the repeated line of Old MacDonald's farm
# Inputs: none
# Outputs: none
def line():
print "Old MacDonald had a farm,",
chorus()

def main():

line()
print "And on that farm he had a cow,",
chorus()
print "With a moo, moo here and a moo, moo there."
print "Here a moo, there a moo, everywhere a moo, moo."
line()

main()

```

Be careful not to define functions with the same name, or you will overwrite the previous function definition without warning!

```>>> def duplicateName():
...     print "First Definition"
...
>>> duplicateName()
First Definition
>>> def duplicateName():
...     print "Second Definition"
...
>>> duplicateName()
Second Definition
```

# Functions with Parameters

• We're not really finished with Old MacDonald yet, because if we want to sing several verses, where each verse uses a different animal name and sound, we would either have to have a huge main() or write a separate function for every possible animal.
• Neither of the functions we wrote in the previous example had parameters. By using parameters, we can define just one function that can handle all of the animals and their sounds, one at a time :
• ```
# verse() prints an entire verse of Old MacDonald's farm
# Inputs: animal - an animal's name
#         sound  - the sound that animal makes
# Outputs: none
def verse(animal, sound):
print
line()
print "And on that farm he had a %s," % (animal),
chorus()
print "With a %s, %s here" % (sound, sound),
print "and a %s, %s there" % (sound, sound)
print "Here a %s, there a %s," % (sound, sound),
print "everywhere a %s, %s." % (sound, sound)
line()

```
• Notice in the parentheses following verse we included animal and sound separated by a comma
These are known as the function's parameters.
• animal and sound serve as variables the function can use - as we see in the line :
• ```    print "And on that farm he had a %s," % (animal),
```
• So, any variables specified between the parentheses in a function's definition are parameters for the function.
• The value of a function's parameters are assigned by evaluating the arguments when the function is called
• ```def main() :

verse("cow", "moo")

main()
```
• In main(), when we called the function verse(), we gave the arguments "cow" and "moo" so the variable animal was assigned "cow" and sound was assigned "moo". The values of those variables were printed out in the song.
• ```linuxserver1.cs.umbc.edu[149] python farm4.py

Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!
And on that farm he had a cow, Ee-igh, Ee-igh, Oh!
With a moo, moo here and a moo, moo there
Here a moo, there a moo, everywhere a moo, moo.
Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!
linuxserver1.cs.umbc.edu[150]
```
• Arguments are always passed to the function in the order they are entered. In our song program, the first argument passed to the function verse will always be assigned into the function's variable named animal and the second argument passed will always be assigned into the function's variable named sound. The names of the variables don't play into this process at all, only the positions in the parameter list matter. To illustrate, let's make a mistake when we call the function from main().
• ```def main() :

verse("oink", "pig")

main()
```
• Here's what it produced :
• ```linuxserver1.cs.umbc.edu[107] python farm7.py

Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!
And on that farm he had a oink, Ee-igh, Ee-igh, Oh!
With a pig, pig here and a pig, pig there
Here a pig, there a pig, everywhere a pig, pig.
Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!
linuxserver1.cs.umbc.edu[108]

```
• Because the arguments are always evaluated before they are passed, you can also use variables as arguments.
```def main():

anAnimal = "pig"
aSound = "oink"
verse(anAnimal, aSound)

main()

```

produces the following output :

```linuxserver1.cs.umbc.edu[153] python farm6.py

Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!
And on that farm he had a pig, Ee-igh, Ee-igh, Oh!
With a oink, oink here and a oink, oink there
Here a oink, there a oink, everywhere a oink, oink.
Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!
linuxserver1.cs.umbc.edu[154]

```

# The Beauty of Modularity

Since we've written these functions, we can easily sing as many verses as we want with very little additional code. In fact, that additional code will be in main(). Here's the final edit of the program.

```# Filename:   farm5.py
# Written by: Sue Evans
# Date:       7/31/09
# Section:    All
# Email:      bogar@cs.umbc.edu
#
# This program "sings" many verses of Old MacDonald's Farm
# making use of the chorus(), line() and verse() functions.

# chorus() prints the chorus of Old MacDonald's farm
# Inputs: none
# Outputs: none
def chorus():
print "Ee-igh, Ee-igh, Oh!"

# line() prints the repeated line of Old MacDonald's farm
# Inputs: none
# Outputs: none
def line():
print "Old MacDonald had a farm,",
chorus()

# verse() prints an entire verse of Old MacDonald's farm
# Inputs: animal - an animal's name
#         sound  - the sound that animal makes
# Outputs: none
def verse(animal, sound):
print
line()
print "And on that farm he had a", animal, "",
chorus()
print "With a %s, %s here" % (sound, sound),
print "and a %s, %s there" % (sound, sound)
print "Here a %s, there a %s," % (sound, sound),
print "everywhere a %s, %s." % (sound, sound)
line()

def main():

verse("cow", "moo")
verse("pig", "oink")
verse("hen", "cluck")
verse("duck", "quack")
verse("cat", "meow")

main()

```

and the output looks like this :

```linuxserver1.cs.umbc.edu[109] python farm5.py

Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!
And on that farm he had a cow  Ee-igh, Ee-igh, Oh!
With a moo, moo here and a moo, moo there
Here a moo, there a moo, everywhere a moo, moo.
Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!

Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!
And on that farm he had a pig  Ee-igh, Ee-igh, Oh!
With a oink, oink here and a oink, oink there
Here a oink, there a oink, everywhere a oink, oink.
Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!

Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!
And on that farm he had a hen  Ee-igh, Ee-igh, Oh!
With a cluck, cluck here and a cluck, cluck there
Here a cluck, there a cluck, everywhere a cluck, cluck.
Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!

Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!
And on that farm he had a duck  Ee-igh, Ee-igh, Oh!
With a quack, quack here and a quack, quack there
Here a quack, there a quack, everywhere a quack, quack.
Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!

Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!
And on that farm he had a cat  Ee-igh, Ee-igh, Oh!
With a meow, meow here and a meow, meow there
Here a meow, there a meow, everywhere a meow, meow.
Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!
linuxserver1.cs.umbc.edu[110]

```

The code we produced is certainly preferable to the naive way to accomplish the same task :

```# Filename:   farm1.py
# Written by: Sue Evans
# Date:       7/31/09
# Section:    All
# Email:      bogar@cs.umbc.edu
#
# This program "sings" Old MacDonald's Farm

def main():

print
print "Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!"
print "And on that farm he had a cow, Ee-igh, Ee-igh, Oh!"
print "With a moo, moo here and a moo, moo there."
print "Here a moo, there a moo, everywhere a moo, moo."
print "Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!"
print
print "Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!"
print "And on that farm he had a pig, Ee-igh, Ee-igh, Oh!"
print "With a oink, oink here and a oink, oink there."
print "Here a oink, there a oink, everywhere a oink, oink."
print "Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!"
print
print "Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!"
print "And on that farm he had a hen, Ee-igh, Ee-igh, Oh!"
print "With a cluck, cluck here and a cluck, cluck there."
print "Here a cluck, there a cluck, everywhere a cluck, cluck."
print "Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!"
print
print "Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!"
print "And on that farm he had a duck, Ee-igh, Ee-igh, Oh!"
print "With a quack, quack here and a quack, quack there."
print "Here a quack, there a quack, everywhere a quack, quack."
print "Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!"
print
print "Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!"
print "And on that farm he had a cat, Ee-igh, Ee-igh, Oh!"
print "With a meow, meow here and a meow, meow there."
print "Here a meow, there a meow, everywhere a meow, meow."
print "Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!"

main()

```

A great thing about using the version with functions is that we can add new animals to the song quickly and easily. Adding one more call to the function verse() produces another whole verse with the animal and sound passed.

```    verse("sheep", "baa")
```

# Kinds of Functions

• When refering to functions, it is sometimes useful to differentiate them into types that depend upon what they return.
• functions - return values
• predicate functions - return booleans
• procedures - return nothing, or None in python
• Let's see an example of a predicate function. Predicate functions typically use the word is as part of their name.
• ```# isPrime() takes a positive integer as an argument
# and returns True if that integer is a prime number
# and False if the number is not prime.
# Input:       a positive integer, num
# Output:      either True or False
# Assumptions: num will be an integer > 1
def isPrime(num):

# try to evenly divide num by all
# numbers between 2 and num - 1
for i in range(2, num):

# if num is evenly divisible by this
# number, then it isn't prime
if num % i == 0:
return False

# if num wasn't divisible by any of
# those numbers, then it's prime
return True

def main():

# print primes from 2 to 11, inclusive
for i in range (2, 12):
if isPrime(i):
print i,

main()
```

Here's the output.

```
linuxserver1.cs.umbc.edu[118] python isPrime.py
2 3 5 7 11
linuxserver1.cs.umbc.edu[119]

```
• All of the functions we wrote for singing "Old MacDonald's Farm" are procedures. Here's one of those functions :
• ```
# chorus() prints the chorus of Old MacDonald's farm
# Inputs:  none
# Outputs: none
def chorus():
print "Ee-igh, Ee-igh, Oh!"

```
• Notice that the outputs say none. Outputs specify what is being returned and so it should say none. The fact that this function prints "Ee-igh, Ee-igh, Oh!" is the effect of the function, not the output. If we wanted to make our function header comment more precise we could add an Effect: line; this is not a requirement.
Here's the change :
• ```
# chorus() prints the chorus of Old MacDonald's farm
# Inputs:  none
# Outputs: none
# Effect:  prints "Ee-igh, Ee-igh, Oh!"
def chorus():
print "Ee-igh, Ee-igh, Oh!"

```
• All of your homeworks and projects should contain a procedure named printGreeting(), which tells the user about the program they are about to run.

# Functions Exercise:

Write a program that will print the even integers in a range that the user enters. Your program must have the following:

• a file-header comment
• function header comments for each function other than main()
• a procedure named printGreeting()
• a predicate function named isEven(value)
• main()
• don't forget to call main()