FUNCTIONS in Python

1
FUNCTIONS in Python
2
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 languages core
  package. Weve 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

3
Why Write Functions?

• Reusability
• Fewer errors introduced when code isnt rewritten
• Reduces complexity of code
• Programs are easier to maintain
• Programs are easier to understand

4
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.

5
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 parameters or arguments
Dont forget the colon to mark the start of a
statement bloc
keyword
6
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 thats returned when the function is
invoked
7
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.

8
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")

9
Functions Formal vs. Actual Paramaters (and
Arguments)

• moveto.py
• from graphics import
• def moveTo(object, point)
• c object.getCenter()
• dx point.getX() - c.getX()
• dy point.getY() - c.getY()
• object.move(dx,dy)
• def main()
• win GraphWin()
• circ Circle(Point(100,100), 20)
• circ.draw(win)
• p win.getMouse()
• moveTo(circ, p)
• win.close()
• center circ.getCenter()
• print center.getX(), center.getY()
• main()

Formal Parameters
Function definition
Actual parameters or arguments
Call or invocation of function Arguments must be
in correct order according to function definition
10
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 variableand 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 theyre in
  different functionsand they could be different
  data types as well.

11
Scope of variables, cont.

• def calc_tax(x) x x 0.08 return xdef
  add_shipping(subtot) subtot subtot 1.04
  return subtotdef 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()

x has scope only in calc_tax function
subtot has local scope only
Invocation/call
firstTotal is sent as a parameter, and returns a
value stored in total
12
Functions Return values

• Some functions dont 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) return x xThe call
  output square(myNum)

Formal parameter
Return value
13
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 (xx) (y y)
  return t

14
Triangle2.py example

• Triangle2.py
• Text of triangle2.py

15
Returning more than one value

• Functions can return more than one value
• def hi_low(x,y) if x gt y return x, y
  else return y, x
• The callhiNum, lowNum hi_low(data1, data2)

16
Functions modifying parameters

• So far weve 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 werent 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

17
Passing parameters by value, example

• def add_shipping(subtot) subtot subtot
  1.04 return subtotdef 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()

Value of firstTotal is handed to add_shipping()
function firstTotal variable is not changed by
add_shipping()
The value returned by add_shipping() is stored in
a new variable, total, in main()
18
Example of flawed function call

• addinterest1.py
• Program illustrates failed attempt to change
  value of a parameter
• def addInterest(balance, rate)
• newBalance balance (1rate)
• balance newBalance
• def test()
• amount 1000
• rate 0.05
• addInterest(amount, rate)
• print amount
• test()

19
Flawed function call corrected

• addinterest2.py
• Illustrates use of return to change value in
  calling program.
• def addInterest(balance, rate)
• newBalance balance (1rate)
• return newBalance
• def test()
• amount 1000
• rate 0.05
• amount addInterest(amount, rate)
• print amount
• test()

20
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

21
Schematic of passing by value
Memory location
Main()
1011001
firstTotal
add_shipping()
Value becomes subtot here
25.90
Return value sent back to main()
total
22
Schematic of passing by reference
Memory location
Main()
1011001
firstTotal
add_shipping()
Memory location passed to subfunction
25.90
Using memory location, actual value of original
variable is changed
23
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.

24
Example of Pythons mutable parameters

• addinterest3.py
• Illustrates modification of a mutable
  parameter (a list).
• def addInterest(balances, rate)
• for i in range(len(balances))
• balancesi balancesi (1rate)
• def test()
• amounts 1000, 2200, 800, 360
• rate 0.05
• addInterest(amounts, 0.05)
• print amounts
• test()

25
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.

26
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, its particular
  usefulits reusable. E.g., if interest rates had
  to be recalculated yearly, one subfunction could
  be called repeatedly.