Functions

Function Definition

What's a function?

Method Definition

What's a method (well… in the context of programming, of course!)?

Function Call Definition

What's a function call?

Argument Definition

What's an argument (again, in the context of functions, of course)?

None Definition

What's None?

Function Definition

What's the syntax for defining a function?

def <function_name>(<zero_or_more_parameters>):
	<statement #1>
	<statement #2>
	.
	.
	<etc.>
	# an optional return statement
	return <some value>

Return

What does return do?

Return Continued

What's value is given back if a function doesn't return anything?

Parameters Example

Using the following function and function call, what are the values of both greeting and num within the function? What's the output?→

def greet_more_input(greeting, num):
	s = greeting * num
	return s

import math
print(greet_more_input("hello".upper() * 2, int(math.sqrt(4))))

And The Tricky One

Using the following function and function call, what are the values of both greeting and num within the function? What's the output?→

def greet_more_input(greeting, num):
	s = greeting * num
	return s

num = "yo"
greeting = 1
print(greet_more_input(num, greeting))

Another Parameters Example

def join_three_strings(a, b, c):
	return "%s %s %s" % (a, b, c)

What are the values of a, b and c in the above function when called as below:→

join_three_strings('one', 'two', 'three')

join_three_strings('three', 'one', 'two')

a = 'three'
b = 'two'
c = 'one'
join_three_strings(c, b, a)

Parameters Summary

• parameters
  • variable names used within a function
  • reference the values passed in as arguments
• parameters are positional; order determines what names match to what variables
  • def f(p1, p2, p3):
  • p1 will refer to the first value passed in
  • p2 to the second
  • etc.

Accessing a Variable Outside of a Function

What do you think will happen here? Will something be printed out? Nothing? Or an error?

s = "hello"

def greet():
	print(s)

greet()

How About Variables Declared Inside a Function?

What do you think will happen here? Will something be printed out? Nothing? Or an error?

def greet():
	s = "hello"
	print(s)

print(s)

How About Parameters?

What do you think will happen here? Will something be printed out? Nothing? Or an error?

def greet(s):
	s = s + "!"
	print(s)

greet("foo")
print(s)

And Lastly…

What do you think will happen here? Will something be printed out? Nothing? Or an error?

s = "hello"

def greet():
	s = "something else"
	print(s)


greet()
print(s)

What Does This All Mean?

A scope holds the current set of available names (variables) and the values that they point to.

• anything that we define in the top level of indentation our program is said to be in the global scope
• in the following example, the variables a and b are in the global scope
• they can be accessed from anywhere, even within the function

a, b = 25, "something"

def foo():
	c = "bar"
	print(b)
	print(c)
# what will this print out?
foo()

Scope

Variables that are defined in your function (one indentation level in), however, are only available within your function. They are local to that function. The example below won't work.

def foo():
	c = "bar"
	return c

print(c)

Scope Continued

Furthermore, variables that are declared within a function that have the same name as a global variable are totally different variables/values! They don't overwrite the outer, global variable (there's a way to do this, though). What will this print?

c = "on toast"
def foo():
	c = "grape jelly"
	print(c)

foo()
print(c)

grape jelly
on toast

Scope Summary

• variables declared outside of a function can be accessed within a function
• variables declared inside of a function cannot be accessed outside of a function (they're out of scope)
• parameters in a function cannot be accessed outside of a function either
• variables declared within a function don't override those declared outside of a function

Return Values

What's the difference between these two definitions of our function? What gets printed out for each code sample? →

Version #1

def join_three_strings(a, b, c):
	return "%s %s %s" % (a, b, c)

print(join_three_strings('one', 'two', 'three'))

Version #2

def join_three_strings(a, b, c):
	print("%s %s %s" % (a, b, c))

print(join_three_strings('one', 'two', 'three'))

Return Values Continued

The first definition (#1) returns a string, while the other (#2) doesn't return a value. Here are the values that are returned from functions #1 and #2:

1. 'one two three'
2. None

Note however, that the actual output is:

# version 1
one two three

# version 2 (the print within the function gets executed, followed by the
# print outside of the function)
one two three
None

The Return Statement

• a function can return a value after it is called
• this is done by using the return statement
• the return statement immediately stops the execution of a function
• …and returns the value that follows it
  • the value can be any value! (return True)
  • it can even be an expression (return 1 + 1)
• if a function doesn't explicitly return a value, it gives back None, a special value that means the absence of a value

Defining a Function vs Calling a Function

What gets printed out for each version of code?

# version 1
def join_three_strings(a, b, c):
	return "%s %s %s" % (a, b, c)

# version 2
def join_three_strings(a, b, c):
	return "%s %s %s" % (a, b, c)

join_three_strings('one', 'two', 'three')

# version 3
def join_three_strings(a, b, c):
	return "%s %s %s" % (a, b, c)

print(join_three_strings('one', 'two', 'three'))

Testing Programs / Functions

So far, we've tested our programs by:

• printing things out to the screen
• manually inspecting the output
• …for every test case that we have

Some shortcomings of manual testing

• it's tedious!
• it's error prone!

What can we do to make testing less tedious and error prone? →

Assertions for Testing

Let's get the computer to test it for us! Assertions are a way to systematically check the state of our program.

• we can test expected values against the actual values by using an assert statement
• the assert statement will program execution if if a specified condition is not True
• for testing, that condition is expected value == actual value

Assert Syntax

assert <some condition>, "a string representing a test"

1. the keyword assert
2. followed by any condition - an expression that returns True or False (usually expected == observed)
3. followed by a comma
4. followed by a string that represents the test

An Assertion Example

Let's use assertions to test an incorrect implementation of our function - one that doesn't have spaces between the strings. →

def join_three_strings(a, b, c):
	return "%s%s%s" % (a, b, c)

assert "ha ha ha" == join_three_strings("ha", "ha", "ha"), "should have spaces"

# output shows line number and error...
Traceback (most recent call last):
  File "foo.py", line 4, in <module>
    assert "ha ha ha" == join_three_strings("ha", "ha", "ha"), "joined string should have spaces"
AssertionError: joined string should have spaces

An Assertion Example That Actually Passes

Let's fix the program… and see what happens. →

def join_three_strings(a, b, c):
	return "%s %s %s" % (a, b, c)

assert "ha ha ha" == join_three_strings("ha", "ha", "ha"), "should have spaces"

# results in no output

Another Assertion Example

Let's use assertions to test an incorrect implementation of an absolute_value function →

def absolute_value(x):
	if x >= 0:
		return x
	else:
		return -1

assert 1 == absolute_value(-1), "absolute value of negative # is positive"
assert 1 == absolute_value(1), "absolute value of positive # is same #"
assert 0 == absolute_value(0), "absolute value of 0 is 0"

Questions About Assertions

• why use assertions
  • to test specific portions of your program
  • to cut down on manual testing
  • they're almost like inline documentation for your functions
• why use assertions over if statements
  • you can actually turn off assertions when you run your program
  • more concise than if statements
  • specifically meant for checking the internal state of your program </section>

Example Question #1

• write a function called join_three_strings
• it should take three arguments: a, b, c
• it should return a single string composed of a, b, and c separated by a space
• handle non-string arguments (see last example)
• use at least two assertions to test

Example Usage:

>>> print(join_three_strings('one', 'two', 'three'))
one two three
>>> print(join_three_strings('1', '2', '3'))
1 2 3
>>> print(join_three_strings(1, 2, 3))
1 2 3

Example Question #1 Solution

def join_three_strings(a, b, c):
	return "%s %s %s" % (a, b, c)

assert "one two three" == join_three_strings('one', 'two', 'three'), "three strings are joined with a space"
assert "1 2 3" === join_three_strings(1, 2, 3), "joins three ints as strings"

Example Question #2

Using the function definition below, what is the value and type of a? →

def join_three_strings(a, b, c):
	return "%s %s %s" % (a, b, c)

a = join_three_strings(4, 'five', 6)