Chapter 5 Functions

• names: "function", "subroutine", "subprogram", "paragraph (COBOL)", "module"
• a function is a piece of code
  • does a specific job
  • has a name (an identifier) attached
  • has a list of things it uses to accomplish the task (parameters)
• Reasons to use / write functions
  • can be reused many times - write once, use many
  • makes it easier to work in teams
  • makes writing easier
    • put off details until necessary - "abstraction"
    • easier to focus on one task at a time
    • write the program one function at a time
  • makes testing easier
  • think of a function as a "black box"
    • all you have to know to use it
      • its name
      • its argument list
      • and what it does or returns
    • the user does not need to know HOW the function does what it does
    • allows for easy "behind the scenes" changes of a function's implementation - user does not need to know
• Syntax of a function - has two parts
  • definition
  • call / invocation
• Syntax of definition
  • def identifier (parameter list) : don't forget the colon!
  • the body is all the lines after the def statement which are indented
  • the body may or may not end with a "return statement"
    • depends on whether the function returns a value or not
  • parameter list can be empty or can have as many identifiers as desired (but don't go overboard - 10 is too many!)
  • parameters cannot be constants or expressions
  • definitions of functions are in the same file as the main function
  • position of the definition in the file does not matter (functions run when they are called)
  • except that one function is usually NOT defined inside another!
  • just because a function is defined in the file, does NOT mean it will run! it must be called or it will never execute!
• Syntax of call to a function - two versions
  • the function does not return a value "non-fruitful"
    • syntax is functionname (arguments) on a line by itself
    • example: win.close()
    • in other words, the statement to call the function is a standalone statement
  • the function DOES return a value (or values) "fruitful"
    • syntax is variable = functionname (arguments)
    • or print(functionname (arguments)
    • or (later) if functionname (arguments):
    • in other words, the call to the function is part of another statement, not a standalone statement
• Functions which return values
  • new statement return
  • causes the function to end execution and return to calling code
  • can use variation return value
  • or return value, value, ...
  • can return variables or more complex expressions
  • "return (x + y)/ 2"
  • don't put code in definition after return - will never execute!
  • if want to return 2 things, "return a, b"
  • the corresponding call is "x, y = fun1(t)" - simultaneous assignment of two values from the return statement to 2 variables
• Semantics of a function - what happens when it is run/called? (textbook calls it "Flow of execution summary")
  • first the call to the function is encountered in the code
  • the code that is doing the calling is "suspended"
  • the arguments' values are copied into the place of the parameters, matching by order
    • this is called "passing by value"
  • any local variables in the function are created as they are used
  • the code for the function begins execution
  • finally the code for the function is finished
    • either the code just runs out - there is no more in the definition
    • or a "return" statement is encountered
  • the return value or values are copied back to the calling code
    • if there is no explicit return value, Python returns the special value None.
  • the copies of the arguments that were put in the parameters are erased
  • any local variables in the function are erased
  • control is passed back to the calling code and the function is over
  • the calling code picks up where it left off
• each call to a function is independent of every other call
  • the parameters are set up anew
  • any local variables inside the function are brand new
  • there is no "memory" of what happened the last time the function was called, each call is like the very first time
• Arguments and parameters of a function
  • Arguments also called "actual parameters", parameters called "formal parameters"
  • we will use "arguments" and "parameters"
  • arguments are real values, parameters are placeholders
  • arguments are in function calls, parameters are in function definitions
  • argument names and parameter names do NOT have to match at all
  • argument types and parameter types should match fairly closely, i.e. numeric to numeric, string to string, object to object - Python will try to convert if they don't match, with unreliable results!
  • the quantity of arguments and variables MUST match (syntax error if they don't!)
  • which argument goes with which parameter is a matter of position - first argument goes with first parameter, second with second, and so on
• Arguments, Parameters, Input and Output
  • arguments are sometimes called the "inputs" to the function.
    • This is different from using the input function to get data from the keyboard!
    • just means that the values come from outside the function and go into the function via the parameter list
  • return values are sometimes called "outputs" of the function.
    • Again, this is different from a print statement!
    • functions can print things to the shell window, just like any Python code
    • BUT most often a function does NO input from the keyboard NOR output to the screen
    • the function receives its data to work on through the parameter list and reports its results through a return value or values
    • the "higher up" code which called the function decides what the function should get and what is to be done with the return value
  • principle called "functional coherence" or "functional cohesion"
    • a function does ONE job, does it well, and does nothing else
    • if you find yourself naming a function "get_value_and_process_and_output_it", think again about its job
    • if a function seems to need 10 or 12 parameters to do its job, it probably has too big a job!
• How to decide what should be in the parameter list vs. what should be defined inside the function vs. what should be a return value
  • ask yourself - is this value known outside the function? if so, it should be passed as a parameter
  • otherwise it should be defined inside the function
  • then ask yourself - is this value one that needs to be known to the calling code when the function is over? if yes, it should be a return value (in a return statement)
  • otherwise it can die with the function
• Scope of a variable (textbook "Variables and parameters are local")
  • the scope of a variable is the place in the code where the variable can be accessed, where the variable is known
  • there are two kinds of scope in Python
    • local
      • the variable (including parameters) is known inside a function
      • and ONLY inside the function
      • created and initialized every time the function is run
      • destroyed when the function is finished running
      • variables with identical names in different functions are completely independent of each other
    • global
      • defined outside of ANY function definition
      • usually at the left margin in the file
      • created by an assignment statement
      • known in ALL functions from its definition onward
      • considered BAD style and very confusing to use globals!!! do NOT do it!
    • beginner tendency to "make everything global, that way I don't have to worry about parameter lists!"
    • doesn't work very well and makes code very confusing!
    • variables have "lifespans"
      • "when does a variable have memory assigned to it?"
      • lifespan of a local variable is the time the function is running
        • "is born" when function starts
        • "dies" when function ends
        • if function is called again later, local variable is again "born" and "dies"
      • global variables have lifespans of the entire program's run
        • created when program runs
        • erased when program is entirely finished just before it returns to the OS / IDE
• Functions can call other functions
  • similar to "functional composition" in math "f(g(h(x, y), z))"
  • when executing, has to evaluate from the inner parentheses outward
  • a return value replaces the call when the function is finished
  • a function CAN call itself
    • this is called "recursion"
    • see a later chapter for more details
• Documentation of a function definition
  • "docstring" - string with triple quotes (multiline) appears at top of definition, just after def line
  • states purpose of function
  • preconditions = parameters - what they mean
  • postconditions = return value(s) or output to screen, whatever the function produces as result
  • you should be able to have one statement at the top which states the purpose of the function while using all of the parameters (if you can't, why is that a parameter?)
  • as well as usual comments on code inside function (design!)
• Functions - can they change their parameters? permanently?
  • change their parameters - inside the function, yes
  • the usual behavior is NOT to be able to change their parameters permanently
  • the "only" way for a function to make any permanent changes is to return a value or values through the return statement
  • There are exceptions to this using lists (see later chapter)
  • example:

    		def fun1 (a, b):
    		   a = a + b
    		   return a
    	when this function is called with x and y 
    		x = 5
    		y = 7
    		p = fun1 (x, y)
    	x is still 5 when the function is done, NOT 12!
    

• The Accumulator Pattern
  • doesn't have anything to do with functions
  • accumulator statement looks like variable = <same variable > <arithmetic operator> <another variable or constant>
  • almost always used inside a loop, to update the variable on the left repeatedly
  • an accumulator variable must be initialized with a value before it is used inside a loop, usually to zero
  • example:

    	start = 0
    	for i in [3, 5, 1, 2, 7]:
    	    start = start + i
            print("Total is", start)
    

  Slides on Stubs and Drivers