Returning Values (CSCI-UA.0002

A Function (Again)

What's a function? →

a function…
- is a named sequence of statements that performs some useful operation
- may or may not take parameters (produce a value)
- may or may not produce a result (return a value)

Examples

What are some examples of built-in functions or functions in modules? →

built-in functions
- print("something")
- int("5")
- intput("enter a number)
functions in modules
- math.sqrt(5)
- sys.exit()

Calling a Function

Define what it means to "call" a function. How do we call a function? →

A function call is the statement that actually executes a function. It causes the functions code to run.

Syntactically, we call a function by writing →:

the function name
followed by parentheses
with zero or more arguments enclosed within those parentheses
(no arguments are ok)

Arguments

Based on the definitions of function and calling a function, how can we define argument? →

an argument is a value provided to a function when the function is called
this value (or values) is used within the function
the argument can be the result of an expression which may involve operators, operands and calls to other functions!
or simply, the input

Arguments / Parameters

What's the difference between an argument and a parameter?

argument: value provided to a function when it's called
parameter: name used inside a function to refer to the value which was passed to it as an argument
we'll see more about this when we create our own functions!

Functions That Return Values

We've used some functions that return values, and we looked at them in an earlier set of slides. What type of values do the following functions give back? →

randint(1, 10)
input("Enter a number")
float(23)

int
str
float

We Can Define Our Own Functions!

def create_greeting(person):
	return 'hello ' + person

What's the name of this function? How many arguments do you think it takes? What does the function do?

create_greeting
one argument
returns a string

Defining a Function - Syntax

Based on our examples, let's figure out how we define a function:

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

The Function Header

the keyword, def (this never changes)
followed by the function's name
- (whatever you want, but something meaningful)
- same rules for variable names apply (alphanumeric and underscores)
parentheses surrounding parameters (if any)
- can just be () if no parameters are required
- multiple parameters are separated by commas
- the parameters specify what information must be provided to the function
a colon to signify the end of the header line

Parameters

A parameter is "a name used inside a function to refer to the value which was passed to it as an argument".

sometimes we'll use parameter and argument interchangeably
note that whatever value you pass in to the function, you can now refer to it within the body using the parameter's name
we'll take a look at this in a little bit…

Function Body

The body of a function:

consists of one or more statements
the values that were passed in as arguments in the call to the function:
- can be accessed by the parameter names
- these names correspond to the position that they were in when the function was called
an optional return statement that specifies to the function that it should give back a value
(most of the functions we write will have a return statement)

…And Back to Parameters

Let's see what that means. Whatever values you pass in to the function, you can now refer to it within the body using the parameter's name (based on the position of the argument).

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

greet_more_input("hello", 5)

Parameters Example 1:

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

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

greet_more_input("hola", 23)

greeting → "hola"
num → 23

Parameters Example 2:

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

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

print(greet_more_input("hey " + "there", math.sqrt(25)))

greeting → "hey there"
num → 5

Parameters Example 3:

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

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

num = "hi"
greeting = 20
greet_more_input(num, greeting)

greeting → "hi"
num → 20

Let's Take a Closer Look

#                     num       greeting
#                       |        |
#                     "hi"      20
#                       |        |
def greet_more_input(greeting, num):
	s = greeting * num
	return s

num = "hi"
greeting = 20
print(greet_more_input(num, greeting))

Function Definition

The entire block of code you wrote, the header and the body of the function, is called the function definition. Here are a few things to note about your function definition:

defining a function doesn't call a function
you must explicitly call it after it is defined…
(and related…) a function must be defined before it's called!
- if you call it before you define it, you get an error
- specifcally a NameError
- (similar to what happens when using an undeclared variable)

Function Definition Example 1:

If this is the only code in your program, and you run it, what will be printed to the screen? Something, nothing, or an error? →

def greet():
	return 'hello'

print(greet())

hello

Function Definition Example 2:

If this is the only code in your program, and you run it, what will be printed to the screen? Something, nothing, or an error? →

def greet():
	return 'hello'

#  nothing (the function was never called after it was defined)

Function Definition Example 3:

If this is the only code in your program, and you run it, what will be printed to the screen? Something, nothing, or an error? →

print(greet())

def greet():
	return 'hello'

#  we called the function before defining it
NameError: name 'greet' is not defined

Program Flow

What we've seen so far:

statements are executed from top to bottom
each line is executed exactly once

Program Flow Coninued

Defining our own functions means:

still top to bottom, so we have to define the function first
but once a function is called…
1. go to function
2. execute that code
3. go back to where function was called
the body of a function can be executed as many times a function is called

Program Flow Example

Let's walk through this program line-by-line →

def exclaim(word, num):
	punctuation = num * '!'
	s = word + punctuation
	return s

print("hello")
print(exclaim("hi", 1))
print("hey there")
print(exclaim("howdy", 10))

Using a Main Function

Sometimes you'll see a function called main() within a program

this signifies that this is the main line of execution
all of the code for the program is written in that function
the last line of the code calls that function
the rationale for doing this is to:
- keep your code organized
- isolate your function definitions from the actual program (handy when creating modules)
we'll see this a bit more later…

Returning Values

we can create fruitful functions, that is… functions that return a value
define a function using def, and just use the keyword return, followed by the value that you want to give back
(you might have noticed the keyword, return in previous examples)

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

Without Return (None)

In this example, we do not have a return statement. This is still syntactically valid, but…

def greet(greeting, num):
	s = greeting * num

print(greet('hello', 5)

If you omit return, you'll get a special value back: None. This prints out None to the screen!

None is a value that means the absence of a value!

So, Now What?

Now that you have a function that returns a value, you can use that function wherever you would use that value.

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

#  using the return value of greet as an argument to input!
response = input(greet("hi", 3))
print(response)

The return Statement

the return immediately stops the execution of a function
…and returns the value that follows it
- the value can be any value!
- it can even be an expression

Some Examples of the Return Statement

These functions are contrived examples of what you can do with return. What type and value do they return? →

def foo():
	return "foo"

def bar():
	return "b" + "ar"

def baz():
	return str(math.sqrt(100)) + "!"

string, "foo"
string, "bar"
string, "10!"

Let's Try Creating a Function That Returns a Value

Write a function that returns the area of a circle (πr²)when given a radius, r.→

import math
def area(r):
	a = math.pi * r * r
	return a

Area, Defined Again

Another way to define our area function:

import math
def area(r):
	return  math.pi * r * r

code is shorter
but no intermediary variable (maybe more difficult to debug?)

Print vs Return

What's the difference between printing in a function and returning a value from a function? →

def greet(greeting, num):
	s = greeting * num
	print(s)

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

Print vs Return Continued

What's the difference between printing in a function and returning a value from a function?

printing alone will not give you back a value for a function!
however, you can print and return
- useful for debugging
- see the example below… where we print out what s is before returning it

def greet(greeting, num):
	s = greeting * num
	print(s)
	return s

Stopping Execution

The return statement stops execution of your function immediately. What gets printed in the following example? →

def foo():
	print("one")
	print("two")
	return "foo"
	print("three")

foo()

"one" and "two" are printed, but three is not because the function has already returned the value "foo"

Another Example…

Stopping execution again…

>>> def area(r):
...   a = math.pi * r * r
...   print("before return")
...   return a
...   print("after return")
... 
>>> area(6)
before return
113.09733552923255

Multiple Return Statements

You can have multiple return statements in your function! Write a function that calculates absolute value. →

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

Some Exercises

create a function that returns the largest factor of a number that isn't the number itself
create two funcions: is_even and is_odd…
- each will take one argument (an int)
- it will use modulo to determine if the number is even or odd
- it will return True or False
- (arguably easier to understand than just modulo alone)
pluralize
- just add s
- special case

Creating Functions

First, Let's Make Sure We're Speaking the Same Language!

A Function (Again)

Examples

Calling a Function

Arguments

Arguments / Parameters

Functions That Return Values

We Can Define Our Own Functions!

Defining a Function - Syntax

The Function Header

Parameters

Function Body

…And Back to Parameters

Parameters Example 1:

Parameters Example 2:

Parameters Example 3:

Let's Take a Closer Look

Function Definition

Function Definition Example 1:

Function Definition Example 2:

Function Definition Example 3:

Program Flow

Program Flow Coninued

Program Flow Example

Using a Main Function

Returning Values

Without Return (None)

So, Now What?

The return Statement

Some Examples of the Return Statement

Let's Try Creating a Function That Returns a Value

Area, Defined Again

Print vs Return

Print vs Return Continued

Stopping Execution

Another Example…

Multiple Return Statements

Some Exercises