Lecture 10 user defined functions and modules

Introduction to
computational thinking
Module 10 : User defined functions
and modules
Asst Prof Michael Lees
Office: N4‐02c‐76
email: mhlees[at]ntu.edu.sg
Module 10 : User defined functions and
modules

Contents
• Function basics
– Dynamics of function call
• Functions using functions
• Scope and namespace
• Functions and scope
• Default parameters
• Recursion
• Stacks
• Modules
modules
2 of 53
Chapter 6,
Chapter 7,
Chapter 16

FUNCTION BASICS
Module 10 : User defined functions and modules
modules

What is a Function?
• From mathematics we know that
functions perform some operation
and return one value.
• They “encapsulate” the
performance of some particular
operation, so it can be used by
others (for example, the sqrt()
function).
modules

Imagine you want to calculate sqrt
x=10
precision =0.001
low = 0
high = max(x, 1)
counter = 0
guess= (low + high) /2.0
while abs (guess ** 2 -x) >
precision and counter <= 100:
if(guess ** 2 < x):
low = guess
else:
high = guess
guess = (low + high) / 2.0
counter += 1
assert counter <= 100, '100
iterations done and no good
answer'
print('Num of iterations:',
counter, 'Estimate:', guess)
modules
5 of 53
vs. sqrt(10)

Why functions?
• Support divide‐and‐conquer strategy
• Abstraction of an operation
• Reuse: once written, use again
• Sharing: if tested, others can use
• Security: if well tested, then secure for reuse
• Simplify code: more readable
modules

Notation
• Consider a function which converts
temperatures in Celsius to temperatures in
Fahrenheit:
– Formula: F = C * 1.8 + 32.0
– Functional notation: F = celsisus2Fahrenheit(C)
where
celsius2Fahrenheit(C) = C*1.8 + 32.0
modules

Python invocation
• Math: F = celsius2Fahrenheit(C)
• Python, the invocation is much the same
F = celsius2Fahrenheit(C)
Terminology: argument “C”
modules

Python Function definition
• Math: g(C) = C*1.8 + 32.0
• Python
def celsius2Fahrenheit (C):
return C*1.8 + 32.0
• Terminology: parameter “C”
modules
Tab

modules

Return
• The return statement indicates the value that
is returned by the function.
• The statement is optional (the function can
return nothing). If no return, the function is
often called a procedure.
modules

Challenge 10.1 – Convert £ to S$
Write a simple function that converts currencies
modules

Thought process
• Functions are to be re‐usable
• What might change?
– Input amount.
– Exchange rate.
• Function might be used by a more complete
program.
• 2 parameters : input amount, exchange rate.
• Return converted amount.
modules

Comments on functions
• A triple quoted string just after the def is
called a docstring
• docstring is documentation of the function’s
purpose, to be used by other tools to tell the
user what the function is used for.
• Very important! – Habits form early!
modules

Operation
modules
def celsius2Fahrenheit (Temp):
return temp*1.8 + 32.0
1. Call copies argument C to
parameter Temp
2. Control transfers to function
“celsius2Farenheit”
c=10
temp=10

Operation cont
modules
3. Expression in celsius2Farenheit is
evaluated
4. Value of expression is
returned to the invoker
def celsius2Fahrenheit (Temp):
return Temp*1.8 + 32.0
temp=10
return 10*1.8+32.0
return 50
F=50

Challenge 10.2 – Create encryption function
Modify the code from module 8, to use a function for encrypting a string
modules

Thought process
• Code Refactoring : disciplined way to
restructure code. (improve readability, reduce
complexity, improve maintainability)
• What should be the parameters?
• What should the function return?
• Can use our ASCIIshift as input.
modules

How to write a function
• Does one thing. If it does too many things, it
should be broken down into multiple
functions (refactored).
• Readable. How often should we say this? If
you write it, it should be readable.
• Reusable. If it does one thing well, then when
a similar situation (in another program)
occurs, use it there as well.
modules

More on how to write
• Complete. A function should check for all the
cases where it might be invoked. Check for
potential errors.
• Not too long. Kind of synonymous with “does
one thing”. Use it as a measure of doing too
much.
modules

Procedures
• Functions that have no return statements are
often called procedures.
• Procedures are used to perform some duty
(print output, store a file, etc.)
• Remember, return is not required.
modules

Multiple returns
• A function can have multiple return
statements.
• Remember, the first return statement
executed ends the function.
• Multiple returns can be confusing to the
reader and should be used carefully.
modules

FUNCTIONS USING FUNCTIONS
modules

Functions calling functions
• Functions are made to solve a problem
and can be called from other functions.
• Functions calling functions does not do
anything we haven’t already seen, but it
can make following the flow of a program
more difficult.
modules

def isFloat(aStr):
"""True if aStr is a float: digits and
at most one decimal point"""
print("*** In the isFloat function.”)
# remove the decimal point
stripped = aStr.replace('.','',1)
# only digits should remain
return stripped.isdigit()
modules

def readFloat(prompt):
"""Keep reading until a valid float is
entered"""
print(" *** In readFloat function.”)
num_str = raw_input(prompt)
# keep asking until valid float
while not isFloat(num_str):
print(’Invalid float, try again’)
num_str = raw_input(prompt)
return float(num_str)
modules

Chaining functions
• isFloat checks to see if a string can be
converted to a float number.
• readFloat uses isFloat as part of the
process of prompting until a float is returned
by the user.
• There is no limit to the “depth” of multiple
function calls.
modules

SCOPE AND NAMESPACE
modules

Defining scope
“The set of program statements over which a
variable exists, i.e. can be referred to.”
• It is about understanding, for any variable,
what its associated value is.
modules

Namespace
• Namespace is an association of name and objects
• William of Orange vs. William of Ockham
• GoogleMaps library vs YahooMaps library –
getAddress(), getDirections()
modules

Namespace continued
• Namespaces in python are important
• It looks like a dictionary, and for the most part
it is (at least for modules and classes).
• For Python, there are potentially multiple
namespaces that could be used to determine
the object associated with a variable.
modules

Namespace
modules
33 of 53
var1
a
myString
23
1.345
“blah”
names python objects

Scope and namespace
• What namespace you might be using is part of
identifying the scope of the variables and
function you are using.
• Remember, by “scope”, we mean the context,
the part of the code, where we can make a
reference to a variable or function.
modules

Multiple Scopes
• Often, there can be multiple scopes that are
candidates for determining a reference.
• Knowing which one is the right one (or more
importantly, knowing the order of scope) is
important.
modules

Two kinds of namespace
• Unqualified namespaces: this is what we have
pretty much seen so far ‐ functions,
assignments, etc.
• Qualified namespaces: these are for modules
and classes (we don’t cover these, but you
should be aware they are different).
modules

Unqualified
• This is the standard assignment and def we
have seen so far.
• Determining the scope of a reference
identifies what its true ‘value’ is.
modules

Unqualified follow LEGB rule
• Local : inside the function in which it was defined.
• Enclosing : If not there, enclosing/encompassing.
Is it defined in an enclosing function?
• Global : If not there, is it defined in the global
namespace?
• Built‐in : Finally, check the built‐in, defined as
part of the special builtin scope.
• Else, ERROR.
modules

Local
• If a reference is assigned in a function, then
that reference is only available within that
function.
• If a reference with the same name is provided
outside the function, the reference is
reassigned.
modules

Local and Global
myVar = 123 # global
def myFn(myVar=456): # parameter is local
yourVar = -10 # assignment local
print(myVar, yourVar)
myFn() # prints 456 -10
myFn(500) # prints 500 -10
myVar # prints 123
yourVar # ERROR
modules

Enclosing
'''Simple test of Python scoping rules'''
def enclosing():
myvariable = ’defined by enclosing'
def enclosed():
print(’scope: ' + myvariable)
myfunction()
enclosing()
modules

Built‐in
• This is just the standard library of Python.
• To see what is there, look at
import __builtin__
dir(__builtin__)
modules

Global Statement
• You can “cheat” by using the global keyword in
a function:
myVar = 100
def myFn():
global myVar
myVar = -1
myFn()
print(myVar) # prints ‐1
modules

FUNCTIONS AND SCOPE
modules

Function’s namespace
• Each function maintains a namespace for
names defined locally within the function.
• Locally means one of two things:
– a name assigned within the function
– an argument received by invocation of the
function
modules

Passing argument ‐> parameter
• For each argument in the function invocation,
the argument’s associated object is passed to
the corresponding parameter in the function.
modules

What is pass?
• The diagram should make it clear that the
parameter name is local to the function
namespace.
• Passing means that the argument and the
parameter, named in two different
namespaces, share an association with the
same object.
• So “passing” means “sharing” in Python.
modules

Assignment changes association
• If a parameter is assigned to a new value, then
just like any other assignment, a new
association is created.
• This assignment does not affect the object
associated with the argument, as a new
association was made with the parameter.
modules

Passing/sharing mutables
• When passing a mutable data structure, it is
possible that if the shared object is directly
modified, both the parameter and the
argument will reflect that change.
• Note that the operation must be a mutable
change, a change of the object. An assignment
is not such a change.
modules

modules
[1, 2, 3]

Lecture 10 user defined functions and modules

More Related Content

What's hot (16)

Similar to Lecture 10 user defined functions and modules (20)

More from alvin567 (13)

Recently uploaded (20)

Lecture 10 user defined functions and modules