Calling Functions

In Python, a function (“procedure”, “subroutine”) is like a program within a program.
To call (“invoke”) a function, write its name followed by a parentheses-enclosed and comma-separated list of arguments:
```
<function_name> (<first_argument> , <...> , <last_argument>)
```

Calling a function:

runs some code, potentially causing effects (like a statement),
returns a value (like an expression).

So functions generalize both statements and expressions.

From now on “statement” means “statement or function call” and “expression” means “expression or function call”.

We already met two functions last week:

type (<expression>)     #  returns the type of an expression to its caller

print (<expression>)    #  prints a textual representation of an expression to the screen

Input and Output Functions

The print function takes an argument and has the effect of printing its value to the screen.
We may also want to take input from the user (keyboard) and give it to the program.

The input function does this:

input (<prompt>)    # returns a string containing the text entered by the user

The prompt is a string that gets printed to let the user know what to enter:
```
input ("What's your name? ")
```

We can store the result in a variable and use it later in the program:

name  =  input ("What's your name? ")
print ('nice to meet you, ' + name + '!')

Composing Functions

Instead of storing the value returned by a function in a variable:

name  =  input ("What's your name? ")
print ('nice to meet you, ' + name + '!')

We can instead use it directly in an argument to another function:

print ('nice to meet you, ' + input ("What's your name? ") + '!')

This is called function composition: using the output (i.e. return value) of one function in an input (i.e. argument) to another.

Coercion Functions

Python includes some basic coercion functions that convert values from one type to another.

These are named after the target type:

str (<expression>)      #  tries to convert the argument to a string

int (<expression>)      #  tries to convert the argument to an integer

float (<expression>)     #  tries to convert the argument to a float

bool (<expression>)     #  tries to convert the argument to a boolean

What they do depends on the argument’s type (see reading for details).
Some conversions are not defined and result in an error.
```
int ('hello!')    #  coercion not defined
```

Others may be counterintuitive, so check how they work before using them.

int (3.9999)      #  may not be
bool ('False')    #  what you expect

Soon we will learn how to write our own conversion functions that do whatever we want.

Implicit Coercion

If an expression has a type different from the one expected, Python may silently try to convert it using a coercion function.
This is called implicit coercion.
Example: the print function expects a string argument, if it finds something else then it silently calls str on it.
```
print (2 + 2)
```
gets automatically converted into
```
print (str (2 + 2))
```
Implicit coercion may seem convenient but is usually bad, especially when combined with overloading.

What will the following do?

print (True * False)

Implicit coercion makes it harder to understand your program and spot bugs. If you want a coercion then say so: make it explicit!

print (str (int (True) * int (False)))  #  although you would never write such a mostrosity

Defining Functions

def my_fun (x , y) :                                                   #  the function header
    print ("i'll add " + str (x) + ' and ' + str (y) + ' for you...')  #  a statement in the function body
    return x + y                                                       #  a return statement in the function body

Function definitions have two parts:

A header consisting of:

the keyword “def” – signals the start of a function definition,
the function name – same rules as for variable names,
the function parameters – a parentheses-enclosed and comma-separated list of variables for referring to the argument values,
a colon “:” that signals the end of the function header.

A body consisting of:

any sequence of statements,
indented with respect to the header,
and containing (at least implicitly) a return statement.

Local Variables

The local variables of a function are its parameters and any variables defined in its body.
The scope (i.e. region of validity) of a local variable is only the function body.
Local variables act like “scratch paper” for a function: when the function call is over, they disappear.

def double (number) :              #  the parameter `number` is a local variable
    result  =  number + number     #  the variable `result` is also a local variable
    return result

Global Variables

In contrast, global variables are variables defined outside of any function.
They may be looked up but not assigned from within a function.*
Trying to assign a global variable from within a function instead creates a local variable with the same name.

Local variables shadow global variables with the same name.

x  =  3                    #  a global variable named `x`

def f () :
    x  =  4                #  a local variable also named `x`
    print ('inside f, x = ' + str (x))

Global variables should be used sparingly: when a function depends on a value, it should generally be passed in as an argument.

Global variables are for program-wide parameters that would be tedious to pass to all functions:

pi  =  22 / 7                      #  a global variable approximating π

def circumference (radius) :       #  we don't pass the global variable in as an argument,
    return 2.0 * pi * radius       #  even though we use it in the function body

Return Statements

A return statement aborts the execution of statements within a function body.
The value of the expression following the keyword “return” is returned to the function’s caller.
If return is not followed by an expression, then “None” is assumed.
If the function body ends without a return statement, then “return None” is assumed.

None and NoneType

In Python there is a type with exactly one value.
The type is called “NoneType” and its only value is called “None”.
The None value provides no information, so the Python interactive interpreter suppresses printing it.

Returning vs Printing

It is important to understand the difference between returning and printing a value.

A value that is returned from a function is available for further use within the program.

It can be assigned to a variable, used in an expression, or passed as an argument to another function.

But a value that is printed to the screen is lost to the program: it can no longer be examined or manipulated.

In fact, print is a function that always returns None:

type (print ('hi'))
print ('hi') == None

Compare:

def double (n) :
    return n + n

def print_double (n) :
    print (n + n)

double (double (2))                 #  works fine
print_double (print_double (2))     #  doesn't work--why?

Functions and Effects

All functions take input through their arguments and give output through their return values.
Some functions also interact with their environment through effects (e.g. print and input).
Functions that do so are called effectful.
In order to communicate with the outside world a program must be effectful.
But you should structure your programs so that as many functions as possible are effect-free.
It’s much more flexible to return a value than to print it.

Function Call Execution

A function call creates a detour in the flow of program execution:

The function arguments are evaluated.
A new variable table is created, assigning the argument values to the function parameters.
Control is passed to beginning of the function body.
Control flows normally within the function body until a return statement is reached.†
The expression following the keyword return is evaluated.‡
The function’s variable table is abandoned.
The return value is assigned to be the value of the function call.
Control is returned to the function call site.

†) If no return is encountered, then “return None” is implied.

‡) If no expression follows return, then “return None” is implied.

Call Graphs

def add_and_greet (x , y) :
    it  =  x + y
    greet_user ()
    return it

def greet_user () :
    it  =  print ('hi there!')

x  =  39
y  =  add_and_greet (1 + 2 , x)

Lets see what this program does by drawing its call graph.

Function Specifications

For a function to work properly, its arguments must fulfill certain preconditions.
Most important among these are their types.
For a function to be useful, its returned value must fulfill certain postconditions.
Most important among these is its type.

Dynamic languages like Python don’t keep track of these things, but you should using documentation string comments:

def quotient (x , y) :
    """
    signature:  int , int -> int
    precondition:  y != 0
    description:  returns the quotient of its arguments
    """
    return x // y

A function signature describes the expected input and output types.
A precondition is a boolean expression, or “predicate”, about the function arguments that should evaluate to True.
You should document every function with a signature, any preconditions and a brief description.

Comp 112

Lecture 2
Calling and Defining Functions

Calling Functions

Input and Output Functions

Composing Functions

Coercion Functions

Implicit Coercion

Defining Functions

Local Variables

Global Variables

Return Statements

None and NoneType

Returning vs Printing

Functions and Effects

Function Call Execution

Call Graphs

Function Specifications

To Do This Week:

Comp 112 Lecture 2 Calling and Defining Functions

Calling Functions

Input and Output Functions

Composing Functions

Coercion Functions

Implicit Coercion

Defining Functions

Local Variables

Global Variables

Return Statements

None and NoneType

Returning vs Printing

Functions and Effects

Function Call Execution

Call Graphs

Function Specifications

To Do This Week:

Comp 112

Lecture 2
Calling and Defining Functions