10/1/2012
1
Functions
CMSC 201
Fall 2012
Instructor: John Park
Lecture Section 01
Discussion Sections 02-08, 16, 17 1
• Adapted from slides by Sue Evans et al.
2
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.
3
10/1/2012
2
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
4
What Are Functions?
• 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
5
Why Use Functions?
• Two main purposes:
• Reuse:
– Can be called many times within a program
– Can be reused and called from other programs
– Validated once, used many times
• Modularity
– Embodies “top-down design”
– Decompose a large task into a sequential series of smaller tasks
– Decompose a task into a hierarchy of subtasks 6
10/1/2012
3
Review of Top-Down Design
• Involves repeatedly decomposing a problem into smaller problems
• Eventually leads to a collection of small problems or tasks each of which can be easily coded
• The function construct in Python is used to write code for these small, simple problems.
Functions
• A Python program is made up of one or more functions, one of which is usually main( ).
• Execution by convention begins with main( )
• When program control encounters a function name, the function is called (invoked).
– Program control passes to the function.
– The function is executed.
– Control is passed back to the calling function.
Sample Programmer-Defined Function
import string
def PrintMessage ( ):
# A very simple function
print “A message for you:\n\n”)
print “Have a nice day!\n”)
return 0
def main ( ):
PrintMessage ( )
main()
10/1/2012
4
Examining printMessage
import string
def PrintMessage (): function header
# A very simple function
print “A message for you:\n\n” function
print “Have a nice day!\n” body
return 0
function definition
def main ( ):
PrintMessage ( ) function call
main()
The Function Call
• Passes program control to the function
• Must match the function definition in number of arguments, and their purpose
def PrintMessage () :
…
def main ( ): same name no arguments
PrintMessage ( )
main()
The Function Definition
• Control is passed to the function by the function call. The statements within the function body will then be executed.
def PrintMessage ( ):
print “A message for you:\n\n”
print “Have a nice day!\n”
• After the statements in the function have completed, control is passed back to the calling function, in this case main( ) . (Note that the calling function does not have to be main( ) .)
10/1/2012
5
A Song-singing Program
• Let's write a program that "sings" Old MacDonald's Farm:
13
# Filename: farm1.py
# Written by: Sue Evans
# Date: 7/31/09
# Section: All
# Email: [email protected]
#
# 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()
A Song-singing Program
• Let's see if it works:
14
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]
A Song-singing Program
• 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.
15
10/1/2012
6
Defining a Function
• Functions are defined using the following form:
• 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.
16
def <function-name>(<parameters>):
<block>
Defining a Function
• 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.
17
Defining a Function
• 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!"
18
def chorus():
print “Ee-igh, Ee-igh, Oh!”
10/1/2012
7
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
19
Calling a Function
20
# [Filename: farm2.py [rest of formal header not shown]
# 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()
Calling a Function
• Does it work correctly?
21
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]
10/1/2012
8
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 :
22
Functions That Call Other Functions
23
# [Filename: farm3.py [rest of formal header not shown]
# 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()
# (continued next page)
Functions That Call Other Functions
24
# (continued)
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()
10/1/2012
9
Functions That Call Other Functions
• Be careful not to define functions with the same name, or you will overwrite the previous function definition without warning!
25
>>> 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 : 26
Functions with Parameters
27
# 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):
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()
10/1/2012
10
Functions with Parameters
• 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 :
28
print "And on that farm he had a %s," % (animal),
Functions with Parameters
• 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
29
def main():
verse("cow", "moo")
main()
Functions with Parameters
• 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.
30
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]
10/1/2012
11
Functions with Parameters
• 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.
31
Functions with Parameters
• To illustrate, let's make a mistake when we call the function from main().
32
def main():
verse(“oink", “pig")
main()
Functions with Parameters
• Here’s what it produced:
33
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]
10/1/2012
12
Functions with Parameters
• Because the arguments are always evaluated before they are passed, you can also use variables as arguments.
34
def main():
anAnimal = "pig"
aSound = "oink"
verse(anAnimal, aSound)
main()
Functions with Parameters
• produces the following output:
35
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:
36
10/1/2012
13
The Beauty of Modularity
37
# [Filename: farm5.py [rest of formal header not shown]
#
# 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()
# (continued next page)
The Beauty of Modularity
38
# (continued)
# 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):
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()
# (continued next page)
The Beauty of Modularity
39
# (continued)
def main():
verse("cow", "moo")
verse("pig", "oink")
verse("hen", "cluck")
verse("duck", "quack")
verse("cat", "meow")
main()
10/1/2012
14
The Beauty of Modularity
• and the output looks like this :
40
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!
The Beauty of Modularity
41
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 Beauty of Modularity
• The code we produced is certainly preferable to the naive way to accomplish the same task :
42
# Filename: farm1.py
# Written by: Sue Evans
# Date: 7/31/09
# Section: All
# Email: [email protected]
#
# 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!"
10/1/2012
15
The Beauty of Modularity
43
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 "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 "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!"
The Beauty of Modularity
44
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()
The Beauty of Modularity
• 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.
45
verse("sheep", "baa")
10/1/2012
16
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:
46
Kinds of Functions
47
# 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
Kinds of Functions
• We use it
• …and here’s the output:
48
def main():
# print primes from 2 to 11, inclusive
for i in range (2, 12):
if isPrime(i):
print i,
main()
linuxserver1.cs.umbc.edu[118] python isPrime.py
2 3 5 7 11
linuxserver1.cs.umbc.edu[119]
10/1/2012
17
Kinds of Functions
• All of the functions we wrote for singing "Old MacDonald's Farm" are procedures. Here's one of those functions :
• 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.
49
def main():
# print primes from 2 to 11, inclusive
for i in range (2, 12):
if isPrime(i):
print i,
main()
Kinds of Functions
• 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 :
• All of your homeworks and projects should contain a procedure named printGreeting(), which tells the user about the program they are about to run.
50
# 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!"
List Exercise
In groups of 3 or 4, 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() 51