Functions Part I (Syntax)

What is a function? A function is a set of statements which is split off into a separate entity that can be used like a “new keyword” It has a name It should have a specific task to do (functional cohesion) It has a parameter list (data that it needs to work on for the task) It is also called a subroutine, subprogram, procedure or module in different languages

Why write code in functions? You can write the code once, use it many times It’s easier to divide work among the members of a team – each one is responsible for a certain function You can put off the details when you are writing the top-level code of the program “abstraction or generalization” and then later, focus on just one function at a time (top down design) You can write the program incrementally, one function at a time (bottom up design) Testing is easier (unit testing)

Why write code in functions? You can think of a function as a ‘black box’ – you only know what goes into it and what should come out of it, not what is going on inside This organization allows for easier changes of a function’s implementation – the function code is all that has to change Software companies often sell libraries of functions – they sell the executable code and documentation of the headers of the functions, that is, the parameter lists and the value that is returned by the function – you don’t get to see the implementation, just the interface. Later the company may implement the function library in a more efficient way – they can send you the update without your having to change your code at all!

A Black Box You can think of a function as a black box. Put certain things IN and certain things (or actions) come OUT. The details of what’s in the box can be postponed for a while. Black Box InputOutput

Syntax of functions – two parts A function has to have a definition And a function needs to be called (otherwise it is not executed)

Syntax of a definition of a function Starts with def identifier (parameters): at left edge of screen Statements follow the def line, indented one tab stop (the “body”) When the lines stopped being indented, the function definition is finished It may or may not end with a return statement Parameter list can be empty or as many identifiers as desired with commas between, parameters are not expressions or constants Where the function definition is placed in the source file is up to you – the main rule is that it must be defined before the first call to the function appears in the file Functions can be defined inside other function definitions. This is generally not necessary – please do not do this in this class

Syntax of function call (invocation) There are two kinds of calls to functions If the function returns a value, the function call must be part of a statement – it cannot stand alone Example: y = sqrt(x) Example: print(sqrt(x)) NOT correct: sqrt(x) # Python allows this to be written but it does # nothing with the result of the function, so it’s a waste of time If the function does not return a value, the function call is a stand-alone statement Example: win.close() Example: circ1.setFill(“red”) # changes the object, does not return a value Not correct: y = win.close() # y will get the value None

Functions Part 2 (Semantics)

Semantics of function definitions What happens when a function definition is encountered in a file that is being executed? When the keyword def is encountered, Python makes a note of the identifier following it, as a function name. All the lines that are indented (the ‘body’) after the def line are recorded as the function definition. The lines of the body are NOT executed at that time. They are simply recorded as part of that function. If there are syntax errors in the function definition, they will NOT be noted at that time

Semantics of a function call (invocation) 1.The function which is doing the calling is paused – put on hold 2.Copies of the argument values are put in the places where the parameters are in the function definition code 3.Execution starts with the start of the function definition and continues until either a return statement is executed or the definition runs out of code – any local variables are created as needed 4.At the point of return, the copies of the arguments and any local variables created are destroyed 5.The return value (or None) is passed back to the function doing the calling 6.The calling function picks up where it left off, using the return value

Scope and Lifespan of Identifiers

Every function has a scope What does that mean? That means that every identifier that is created in a function (that’s variables and function names) belongs to that function The identifier is accessible (useable) in that function and nowhere else, it is local to the function This is the default behavior of variables (not just in Python) It is a GOOD thing because it allows you to focus on solving the problem that the function is supposed to solve, without worrying about what other functions used for names for their variables

Global variables The other scope that exists in a program file is “global”. This is an identifier which is defined outside of ALL function definitions An identifier which is global can be accessed anywhere in the file, in any function which appears below the definition of the identifier Using Global variables is considered NOT good style – and are not allowed in this class Some people want to do it because they think it makes functions easier to write – no parameter lists! Everything is global! If parameter lists are very difficult for you, then you need to understand your function’s purpose. If you cannot decide what needs to be a parameter, ask yourself “will the function get this info from outside, or will it generate it itself?”

Why global variables are bad style If you want to copy a function to use in another program, and the function uses a global variable, you must also copy the global variable definition If you are working as part of a team on a program, if you create a global variable, there is NO WAY to prevent other team members from using/changing your global – you have no way to control access If you want a function to be general, you do NOT use global variables – it is much more difficult to keep changing the global variable between calls than it is to call the function with different arguments They make testing and debugging much harder!

Lifespan of a variable How long does a variable “live”? That is, when during the execution does a variable have memory and retain its value? This is a dynamic way of thinking about variables, as opposed to scope, which is more static If you had to describe the scope of a variable, you could print out the code of a program and circle the scope on the paper – it does not change If you had to describe the lifespan of a variable, you would have to describe when the variable was created and when it was destroyed, which varies depending on the execution of the program

Lifespans The lifespan of a variable local to a function is from the time it is created in the function’s run, until the function ends (and the memory allocated to the variable is released) It’s the same for parameters to that function also. The lifespan of a global variable is from the time its definition is encountered during the execution of the whole program, until the program is finished If a function with locals is called several times, then those variables are created and destroyed, created and destroyed, over and over for each call, their lifespan is intermittent

Passing Parameters by value

Can a function change a parameter permanently? Given this little function def fun1 (a): a = 15 Does it change its parameter inside the function? Yes. After that statement, a would be 15. How long would a be 15? Until it was changed again or until the function ended Does it change the argument which was used to call the function, that matched the parameter? No, it does not.

Passing by value In Python the default way that arguments are passed to become parameters in a function is by value. That means that the function gets a copy of the argument’s value for the parameter to use. Whatever happens to the parameter in the function has NO effect on the argument in the calling code. Making permanent changes is what the return statement is for. You use the return statement to send back values to the calling code.

Why? Why discuss this? This is described in the other examples of functions Python and other languages have another way to pass arguments to parameters which does allow for a permanent change This way is called passing by reference We will see this later when we get into lists. For now, just remember that passing by value is the default way and it means that functions do NOT make permanent changes to their parameters.

Call Stacks, Arguments and Returns And a bit about Recursion

Functions can call other functions! It is a natural tendency to break a big problem up into smaller problems This can be repeated several times – funA can be broken up into funA1 and funA2 and funA3, which can be broken into funA11 and funA12 and so on The execution proceeds just as in other examples of function calls. The interpreter keeps track of all these function calls using a data structure called a “call stack”.

More semantics - Call stacks (stack frames) To keep track of all the activity involved in a function call, the interpreter uses a data structure called a “call stack” It is a stack of records, each record is about a function call. When a function call is made, a record of that fact is put on top of the call stack. That indicates that that function is the one executing. When a function call is finished and is ready to return, its record is removed from the top of the stack to say it is no longer the one running. The record underneath that is the one belonging to the function which called.

More semantics – Arguments and Parameters Parameters are named in the def statement (can only be identifiers) They are placeholders, waiting to be filled in when the function runs There can be any number of parameters (but don’t go overboard! more than 10 is excessive) Arguments are named in the function call Arguments have values which are copied to the parameters Arguments can be identifiers, expressions, constants The number of arguments must match the number of parameters The names of arguments do NOT have to match the names of the parameters The types of arguments and parameters should match or at least be similar

The return statement The return statement tells Python that the execution of the current function (the function that the return statement is in) is done and that control passes back to the function which called it The return statement can have nothing after the keyword, in which case Python returns the special value None Or the return statement can have one or more expressions after the keyword (yes, a Python function can return multiple values!) When the return statement is executed, the function is finished – therefore, do NOT put code after a return statement, it will never execute!

Recursion Functions can call themselves! That is called Recursion. See chapter 12 for details. Recursion is a powerful technique but must be written carefully or it will cause infinite loops. Don’t worry about recursion until it is covered in class

Documenting a function

Documenting a function definition We have a template for information that we need you to put at the top of each function - if you do this as part of your design, you will be ready when you write the implementation The name of the function The purpose of the function The preconditions = the parameters – their meaning, not just their number! The postconditions = the return value and/or output The design

Example: ‘’’ function draw_circle purpose: draws the circle specified on the graphics window, using the Zelle graphics library preconditions: x and y of center of circle, radius of circle, color of line to draw with, and graphwin object to display circle on postconditions: nothing returned, circle as specified drawn on given window Design 1.Create circle object with point and radius provided 2.Set the color of the circle to given color 3.Draw the circle ‘’’

A docstring Some people and software companies have a standard requirement of putting all this information in a triply-quoted string at the very top of the function. It’s called a “docstring” in that case Some software that professionals use can actually pull out those comments to produce documentation for their company In this class it’s up to you whether you use the ‘’’ or the # to make these comments Of course, you put your implementation between the lines of design comments, as usual, when writing the Python code