CHAPTER 5

Defining
Functions

Copyright © 2015 Pearson Education, Inc. Publishing as Pearson Addison-Wesley

Introduction to Functions
 Function: group of statements within a
program that perform as specific task
Usually one task of a large program
Functions can be executed in order to perform
overall program task
Known as divide and conquer approach
 Modularized program: program wherein
each task within the program is in its
own function
 Benefits of Modularizing a
Program with Functions
 The benefits of using functions include:
 Simpler code
 Code reuse
write the code once and call it multiple times
 Better testing and debugging
Can test and debug each function individually
 Faster development
 Easier facilitation of teamwork
Different team members can write different
functions
Designing a Program to Use
Functions
 In a flowchart, function call shown as
rectangle with vertical bars at each side
Function name written in the symbol
Typically draw separate flow chart for each
function in the program
End terminal symbol usually reads Return
 Top-down design: technique for
breaking algorithm into functions
Designing a Program to Use
Functions (cont’d.)
 Hierarchy chart: depicts relationship between
functions
 AKA structure chart
 Box for each function in the program, Lines
connecting boxes illustrate the functions called by
each function
 Does not show steps taken inside a function
 Use input function to have program wait for
user to press enter
Designing a Program to Use
Functions (cont’d.)
 Void Functions and Value-
Returning Functions
 A void function:
 Simply executes the statements it contains and then
terminates.
 A value-returning function:
 Executes the statements it contains, and then it
returns a value back to the statement that called it.
The input, int, and float functions are
examples of value-returning functions.
Defining and Calling a Function

 Functions are given names

Function naming rules:
Cannot use key words as a function name
Cannot contain spaces
First character must be a letter or underscore
All other characters must be a letter, number or
underscore
Uppercase and lowercase characters are distinct
Defining and Calling a Function
(cont’d.)
 Function name should be descriptive of
the task carried out by the function
Often includes a verb
 Function definition: specifies what
function does
 def function_name():
 statement
 statement
Defining and Calling a Function
(cont’d.)
 Function header: first line of function
Includes keyword def and function name,
followed by parentheses and colon
 Block: set of statements that belong
together as a group
Example: the statements included in a
function
Defining and Calling a Function
(cont’d.)
 Call a function to execute it
When a function is called:
Interpreter jumps to the function and executes
statements in the block
Interpreter jumps back to part of program that
called the function
 Known as function return
Defining and Calling a Function
(cont’d.)

 main function: called when the

program starts
Calls other functions when they are needed
Defines the mainline logic of the program
 Indentation in Python

 Each block must be indented

Lines in block must begin with the same
number of spaces
Use tabs or spaces to indent lines in a block, but
not both as this can confuse the Python interpreter
IDLE automatically indents the lines in a block
Blank lines that appear in a block are ignored
 Local Variables
 Local variable: variable that is assigned
a value inside a function
Belongs to the function in which it was created
Only statements inside that function can access it,
error will occur if another function tries to access
the variable
 Scope: the part of a program in which a
variable may be accessed
For local variable: function in which created
 Local Variables (cont’d.)
 Local variable cannot be accessed by
statements inside its function which
precede its creation
 Different functions may have local
variables with the same name
Each function does not see the other
function’s local variables, so no confusion
 Passing Arguments to
Functions
 Argument: piece of data that is sent
into a function
Function can use argument in calculations
When calling the function, the argument is
placed in parentheses following the function
name
Passing Arguments to
Functions (cont’d.)
 Passing Arguments to
Functions (cont’d.)
 Parameter variable: variable that is assigned
the value of an argument when the function
is called
 The parameter and the argument reference the same
value
 General format:
 def function_name(parameter):
 Scope of a parameter: the function in which the
parameter is used
Passing Arguments to
Functions (cont’d.)
Passing Multiple Arguments

 Python allows writing a function that accepts

multiple arguments
Parameter list replaces single parameter
Parameter list items separated by comma
 Arguments are passed by position to
corresponding parameters
First parameter receives value of first
argument, second parameter receives value
of second argument, etc.
Passing Multiple Arguments
(cont’d.)
 Keyword Arguments
 Keyword argument: argument that specifies
which parameter the value should be passed
to
Position when calling function is irrelevant
General Format:

function_name(parameter=value)
 Possible to mix keyword and positional
arguments when calling a function
Positional arguments must appear first
 Introduction to Value-Returning
Functions: Generating Random Numbers

 void function: group of statements within a

program for performing a specific task
Call function when you need to perform the
task
 Value-returning function: similar to void
function, returns a value
Value returned to part of program that called
the function when function finishes executing
 Writing Your Own Value-
Returning Functions
 To write a value-returning function, you write
a simple function and add one or more
return statements
Format: return expression
The value for expression will be returned to the
part of the program that called the function
The expression in the return statement can
be a complex expression, such as a sum of
two variables or the result of another value-
returning function
 Writing Your Own Value-
Returning Functions (cont’d.)
 How to Use Value-Returning
Functions
 Value-returning function can be useful in
specific situations
Example: have function prompt user for input
and return the user’s input
Simplify mathematical expressions
Complex calculations that need to be
repeated throughout the program
 Use the returned value
Assign it to a variable or use as an argument
in another function
 Returning Strings
 You can write functions that return
strings
 For example:
 Returning Boolean Values
 Boolean function: returns either True
or False
Use to test a condition such as for decision
and repetition structures
Common calculations, such as whether a number
is even, can be easily repeated by calling a
function
Use to simplify complex input validation code
 Returning Multiple Values
 In Python, a function can return
multiple values
Specified after the return statement
separated by commas
Format: return expression1,
expression2, etc.
When you call such a function in an
assignment statement, you need a separate
variable on the left side of the = operator to
receive each returned value
 Global Variables and Global
Constants
 Global variable: created by assignment
statement written outside all the functions
Can be accessed by any statement in the
program file, including from within a function
If a function needs to assign a value to the
global variable, the global variable must be
redeclared within the function
General format: global variable_name
 Global Variables and Global
Constants (cont’d.)
 Reasons to avoid using global variables:
Global variables making debugging difficult
Many locations in the code could be causing a
wrong variable value
Functions that use global variables are usually
dependent on those variables
Makes function hard to transfer to another program
Global variables make a program hard to
understand
 Global Constants
 Global constant: global name that
references a value that cannot be
changed
Permissible to use global constants in a
program
To simulate global constant in Python, create
global variable and do not re-declare it within
functions
Storing Functions in Modules
 In large, complex programs, it is
important to keep code organized
 Modularization: grouping related
functions in modules
Makes program easier to understand, test,
and maintain
Make it easier to reuse code for multiple
different programs
Import the module containing the required function
to each program that needs it
Storing Functions in Modules
(cont’d.)
 Module is a file that contains Python code
Contains function definition but does not
contain calls to the functions
Importing programs will call the functions
 Rules for module names:
File name should end in .py
Cannot be the same as a Python keyword
 Import module using import statement