COMP1730/COMP6730 Programming for Scientists
Functions
Lecture outline
* Function definition.
* Function calls & order of evaluation.
* Assignments in functions; local variables. * Function testing & documentation.
Functions
* In programming, a function is a piece of the program that is given a name, and can be called by that name.
* Functions definitions promote abstraction (“what, not how”) and help break a complex problem into smaller parts.
* To encapsulate computations on data, functions have parameters and a return value.
Function definition (reminder)
name
def change in percent(old, new):
4 spaces
diff = new – old
return (diff / old) * 100
suite
* A function definition consists of a name and suite.
* The extent of the suite is defined by indentation, which must be the same for all statements in the suite (standard is 4 spaces).
Function definition
parameters
def change in percent(old, new): diff = new – old
return (diff / old) * 100
* Function parameters are (variable) names; they can be used (only) in the function suite.
* Parameters’ values will be set only when the function is called.
* return is a statement: when executed, it causes the function call to end, and return the value of the expression.
Function call
* To call a function, write its name followed by its arguments in parentheses:
>>> change in percent(483, 530) -8.867924528301886
* The arguments are expressions.
* Their number should match the parameters.
– Some exceptions; more about this later.
* A function call is an expression: it’s value is the value returned by the function.
Function Call Execution
Order of evaluation
* The python interpreter always executes instructions one at a time in sequence; this includes expression evaluation.
* To evaluate a function call, the interpreter:
– First, evalutes the argument expressions, one
at a time, from left to right.
– Then, executes the function suite with its
parameters assigned the values returned by the argument expressions.
* Same with operators: first arguments (left to right), then the operation.
The call stack
* When evaluation of a function call begins, the current instruction sequence is put “on hold” while the expression is evaluated.
* When execution of the function suite ends, the interpreter returns to the next instruction after where the function was called.
* The “to-do list” of where to come back to after each current function call is called the stack.
import math
# Convert degrees to radians. def deg to rad(x):
return x * math.pi / 180
# Take sin of an angle in degrees. def sin of deg(x):
x in rad = deg to rad(x) return math.sin(x in rad)
ans = sin of deg(23) print(ans)
1 import math
2 def deg to rad(x):
…
3 def sin of deg(x):
…
4 ans=sin of deg(23)
5 x in rad=deg to rad(23) 7 x in rad=0.4014
8 return math.sin(0.4014)
6 return 23*math.pi/180
9 ans = 0.3907
10 print(ans
stack depth
import math
def deg to rad(x):
return x * math.pi / 180
def sin of deg(x):
x in rad = deg to rad(x) return math.sin(x in rad)
answer = sin of deg(23)
(Image from pythontutor.com)
import math
def deg to rad(x):
return x * math.pi / 180
def sin of deg(x):
x in rad = deg to rad(x)
return math.sin(x in rad) answer = sin of deg(23)
(Image from pythontutor.com)
import math
def deg to rad(x):
return x * math.pi / 180
def sin of deg(x):
x in rad = deg to rad(x) return math.sin(x in rad)
answer = sin of deg(23)
(Image from pythontutor.com)
import math
def deg to rad(x):
return x * math.pi / 180
def sin of deg(x):
x in rad = deg to rad(x) return math.sin(x in rad)
answer = sin of deg(23)
(Image from pythontutor.com)
import math
def deg to rad(x):
return x * math.pi / 180
def sin of deg(x):
x in rad = deg to rad(x) return math.sin(x in rad)
answer = sin of deg(23)
(Image from pythontutor.com)
Assignments in functions
* Variables assigned in a function (including parameters) are local to the function.
– Local variables are “separate” – the interpreter uses a new namespace for each function call.
– Local variables that are not parameters are undefined before the first assignment in the function suite.
– Variables with the same name used outside the function are unchanged after the call.
* The full story is a little more complicated – we’ll return to it later in the course.
Functions with no return
* If execution of a function suite reaches the end of the suite without encountering a return statement, the function call returns the special value None.
– None is used to indicate “no value”.
– The type of None is NoneType (different from
any other value).
* In interactive mode, the interpreter does not print the return value of an expression when the value is None.
Side effects and return values
* An expression evaluates to a value.
* A statement does not return a value, but executing it causes something to happen, e.g.,
– a number = 2 + 3: variablea number becomes associated with the value 5;
– print(2 + 3) : the value 5 is printed. This is called a side effect.
* We can write functions with or without side effects, and functions that do or don’t return a value (other than None).
* Functions with side effects and None return: – robot.drive right()
– print(…)
* Functions with return value and no side effect: – math.sin(x)
– change in percent(old, new)
* Functions with side effects and return value? – Possible.
* Functions with no side effect and None return value?
Functions of functions
* In python, functions are also values; a function can be passed as argument to another function.
def gradient(f, x, d):
return (f(x + d) – f(x – d)) / (2*d)
ans = gradient(math.sin, math.pi/4, 0.1)
Testing and Documentation
Function testing
* A function is a logical unit of testing.
– Specify the assumptions (for example, type
and range of argument values);
– Test a variety of cases under the assumptions.
* What are “edge cases”?
– Typical (numeric) examples: values equal
to/less than/greater than zero; very large and very small values; values of equal and opposite signs; etc.
* Remember that floating-point numbers have limited precision; == can fail.
>>> change in percent(1, 2) 100.0
>>> change in percent(2, 1) -50.0
>>> change in percent(1, 1) 0.0
>>> change in percent(1, -1) -200.0
>>> change in percent(0, 1) ZeroDivisionError
The function docstring
def change in percent(old, new): ’’’Return change from old to new, as a percentage of the old value.
old value must be non-zero.’’’ return ((new – old) / old) * 100
* A docstring is a string literal written as the first statement inside a function’s suite.
* Acts like a comment, but accessible through the built-in help system.
* Describe what the function does (if not obvious from its name), and its limits and assumptions.
Reviews
There are no reviews yet.