FUNCTIONS in

Python
What Are Functions?

• Functions are sub-programs which perform tasks which

may need to be repeated
• Some functions are “bundled” in standard libraries which
are part of any language’s core package. We’ve already
used many built-in functions, such as input(), eval(), etc.
• Functions are similar to methods, but may not be
connected with objects
• Programmers can write their own functions
Why Write Functions?

• Reusability
• Fewer errors introduced when code isn’t rewritten
• Reduces complexity of code
• Programs are easier to maintain
• Programs are easier to understand
Function Elements

• Before we can use functions we have to define them. So there are

two main elements to functions:

• 1. Define the function. The function definition can appear at the

beginning or end of the program file.
• 2. Invoke or call the function. This usually happens in the body of the
main() function, but subfunctions can call other subfunctions too.
Function definitions
• A function definition has two major parts: the definition head and the
definition body.
• The definition head in Python has three main parts: the keyword def, the
identifier or name of the function, and the parameters in parentheses.
• def average(total, num):

identifier
Formal Don’t forget the colon :
keyword
parameters or to mark the start of a
arguments statement bloc
Function body

• The colon at the end of the definition head marks the start of the
body, the bloc of statements. There is no symbol to mark the end of
the bloc, but remember that indentation in Python controls
statement blocs.
• def average(total, num):
x = total/num
return x

Function body

The value that’s returned

when the function is
invoked
Workshop

• Using the small function defined in the last slide, write a command
line program which asks the user for a test score total and the
number of students taking the test. The program should print the test
score average.
 Happy Birthday Example:
Function Flow
• # happy.py
• # Simple illustration of functions.

• def happy():
• print "Happy Birthday to you!"

• def sing(person):
• happy()
• happy()
• print "Happy birthday, dear", person + "."
• happy()

• def main():
• sing("Fred")
• print
• sing("Lucy")
• print
• sing("Elmer")
•
• main()
Functions: Formal vs. Actual
Paramaters (and Arguments)
• # moveto.py
Formal Parameters
• from graphics import *
• def moveTo(object, point):
Function definition
• c = object.getCenter()
• dx = point.getX() - c.getX()
• dy = point.getY() - c.getY()
• object.move(dx,dy)
Actual parameters or
• def main(): arguments
• win = GraphWin()
• circ = Circle(Point(100,100), 20)
• circ.draw(win)
• p = win.getMouse()
Call or invocation of function;
• moveTo(circ, p)
Arguments must be in correct
• win.close() order according to function
• center = circ.getCenter() definition
• print center.getX(), center.getY()
• main()
Scope of variables

• Variables are “valid” only within the function in which they are
declared/initialized. The scope of the variable is LOCAL. Only when a
variable is passed as a parameter to a function can another function
“see” or use the variable—and then only its value.
• Thus it is possible to have two variables named the same within one
source code file, but they will be different variables if they’re in
different functions—and they could be different data types as well.
Scope of variables, cont.
x has scope only in calc_tax function
• def calc_tax(x):
x = x * 0.08
return x
def add_shipping(subtot):
subtot has local scope only
subtot = subtot * 1.04
return subtot
def main():
units = input(“Please enter the # of units”)
firstTotal = units * 5.00 Invocation/call
total = add_shipping(firstTotal)
total = total + calc_tax(total)
print “Your total is: “, total
firstTotal is sent as a parameter,
main() and returns a value stored in total
Functions: Return values

• Some functions don’t have any parameters or any return values, such
as functions that just display. See Happy Birthday ex. above. But…
• “return” keyword indicates what value(s) will be kicked back after a
function has been invoked
• def square(x):
Formal parameter
return x * x
The call: output = square(myNum) Return value
Return value used as argument:
Example of calculating a hypotenuse
• num1 = 10
• num2 = 14
• Hypotenuse = math.sqrt(sum_of_squares(num1, num2))

• def sum_of_squares(x,y)
t = (x*x) + (y * y)
return t
Triangle2.py example

• Triangle2.py
• Text of triangle2.py
• Task: Create a user-defined function that
calculates the factorial of a number.
o The function should take an integer as an
argument and return its factorial.
o Use recursion or a loop to compute the
factorial.
•Task 2 :
• Create two user-defined
functions: is_even() and is_odd().
Returning more than one value

• Functions can return more than one value

• def hi_low(x,y):
if x >= y
return x, y
else: return y, x
• The call:
hiNum, lowNum = hi_low(data1, data2)
Functions modifying parameters
• So far we’ve seen that functions can accept values (actual
parameters), process data, and return a value to the calling function.
But the variables that were handed to the invoked function weren’t
changed. The called function just worked on the VALUES of those
actual parameters, and then returned a new value, which is usually
stored in a variable by the calling function. This is called passing
parameters by value
Passing parameters by value,
example
• def add_shipping(subtot):
subtot = subtot *Value of firstTotal is handed to
1.04
return subtot add_shipping() function; firstTotal variable is
not changed by add_shipping()

def main():
units = input(“Please enter the # of
units”)
firstTotal = units * 5.00
total = add_shipping(firstTotal)
# total = total + calc_tax(total)
print “Your total is: “, total
main()The value returned by add_shipping() is stored in a new
variable, total, in main()
Example of flawed function call

• # addinterest1.py
• # Program illustrates failed attempt to change value of a parameter

• def addInterest(balance, rate):

• newBalance = balance * (1+rate)
• balance = newBalance

• def test():
• amount = 1000
• rate = 0.05
• addInterest(amount, rate)
• print amount
•
• test()
Flawed function call corrected

• # addinterest2.py
• # Illustrates use of return to change value in calling program.

• def addInterest(balance, rate):

• newBalance = balance * (1+rate)
• return newBalance

• def test():
• amount = 1000
• rate = 0.05
• amount = addInterest(amount, rate)
• print amount

• test()
Modifying parameters, cont.

• Some programming languages, like C++, allow passing parameters by

reference. Essentially this means that special syntax is used when
defining and calling functions so that the function parameters refer to
the memory location of the original variable, not just the value stored
there.
• PYTHON DOES NOT SUPPORT PASSING PARAMETERS BY REFERENCE
Schematic of passing by value
Memory location

1011001
firstTotal
add_shipping()

25.90 Value becomes

subtot here
Main()
Return value sent
back to main()
total
Schematic of passing by
reference
Memory location

1011001
firstTotal
add_shipping()

25.90 Memory
location passed
Main()
to subfunction
Using memory
location, actual value
of original variable is
changed
Passing lists in Python

• Python does NOT support passing by reference, BUT…

• Python DOES support passing lists, the values of which can be
changed by subfunctions.
Example of Python’s mutable
parameters
• # addinterest3.py
• # Illustrates modification of a mutable parameter (a list).

• def addInterest(balances, rate):

• for i in range(len(balances)):
• balances[i] = balances[i] * (1+rate)

• def test():
• amounts = [1000, 2200, 800, 360]
• rate = 0.05
• addInterest(amounts, 0.05)
• print amounts

• test()
Passing lists, cont.

• Because a list is actually a Python object with values associated with

it, when a list is passed as a parameter to a subfunction the memory
location of that list object is actually passed –not all the values of the
list.
• When just a variable is passed, only the value is passed, not the
memory location of that variable.
• Ergo, when the memory location of a list object is passed, a
subfunction can change the values associated with that list object.
Modularize!

• Functions are useful in any program because they allow us to break

down a complicated algorithm into executable subunits. Hence the
functionalities of a program are easier to understand. This is called
modularization.
• If a module (function) is going to be used more than once in a
program, it’s particular useful—it’s reusable. E.g., if interest rates had
to be recalculated yearly, one subfunction could be called repeatedly.
Congratulations !!

You’ve been selected to be part

of the ATS-Ajman Media team –

Photography