Parameters and Return Values

The functions in the previous chapter always performed exactly the same work. Parameters let different calls supply different information, and return values let a function hand information back to its caller.

Parameters and Arguments

Consider:

In the definition:

def greet(name):

name is a parameter. It is a name used inside the function.

In the call:

greet("Ada")

"Ada" is an argument. It is the value supplied by this call.

When Python calls a function, it evaluates each argument and gives the resulting value a local parameter name.

For the first call above, local name refers to the string "Ada". For the second call, that call’s local name refers to "Grace".

Each Call Has Its Own Local Names

In this version of greet, the function also gives its message a name. Step through the two calls and watch the state panel. Each call has its own frame, which groups the names belonging to that call.

The first call has name referring to "Ada" and message referring to "Hello, Ada!". When that call finishes, its frame closes. The second call starts with its own name and creates its own message for "Bob".

The local names from the first call are not reused by the second call.

More Than One Parameter

A function can receive several pieces of information:

def print_session(subject, minutes):
    print(f"{subject}: {minutes} minutes")


print_session("Programming", 45)

This call uses positional arguments. Each argument is matched with a parameter by position:

subject → "Programming"
minutes → 45

Order matters. Python cannot know that this call probably reflects a mistake:

print_session(45, "Programming")

Both arguments can still be bound to the two parameter names, although the displayed message no longer makes sense.

Trace how arguments are bound to parameters in several calls:

Now try writing a function’s missing step in natural language. The definition header and both calls are given; write the step that belongs inside the function body.

8
14

Returning Information

Printing is useful when a function’s job is to communicate with the user. Many functions instead need to produce a value for other code to use. Use return for that:

Step through the same program. Watch when answer gets its value and when output appears.

The call double(6) evaluates to the returned value 12. It can therefore appear anywhere that value could appear:

print(double(6) + 1)
print(double(double(3)))

The first line prints 13. In the second line, the inner call returns 6, which becomes the argument of the outer call. The outer call returns 12.

Printing and Returning Are Different Jobs

Compare:

def print_double(number):
    print(number * 2)


def double(number):
    return number * 2

print_double(5) displays 10. By contrast:

result = double(5)

does not display the calculation. It hands 10 back to the caller and stores it in result.

Printing displays information. Returning supplies a value to the caller.

A calculation function is usually more flexible when it returns its result. The caller can then print it, store it, compare it, or use it in another calculation.

A Function Without an Explicit return Returns None

Run this example:

Step through the same program. Compare what is printed with the value assigned to result.

Every function call evaluates to a value. If execution reaches the end of a function without an explicit return, Python returns the special value None implicitly.

Here the function displayed 14, but the call returned None rather than a calculated number. None is a real Python value commonly used to represent the absence of another useful result. A function can also deliberately write return None; omitting return and explicitly returning None produce the same returned value, although the programmer’s intention may differ.

The next exercises ask you to submit only a function definition. While working, add temporary calls below the definition and run the program to check different arguments. For a calculation function, put the call inside print(...) to see its returned value. Remove the temporary calls before submitting; the grader will make its own calls.

Write a function that uses its parameter in a printed message:

BADGE: Nova

Trace displayed and returned values:

Then write a function that calculates and returns a result from two arguments:

return Ends the Current Call

When Python executes return, the current function call ends immediately:

def describe_temperature(temperature):
    if temperature < 0:
        return "freezing"

    if temperature < 15:
        return "cold"

    return "mild or warm"

With -5, the first return ends the call. The later conditions are not evaluated. Chapter 5 applies this rule carefully inside loops.

Trace a call to another function with more than one return statement:

def classify(number):
    if number < 0:
        return "low"

    return "ok"

print(classify(-3))

Finish by explaining how printed output and returned values follow different paths:

def show_square(number):
    print(number * number)

def square(number):
    return number * number

shown = show_square(4)
calculated = square(4)
print(shown)
print(calculated)

Check Your Understanding

1. How does a parameter differ from an argument?
2. How are positional arguments matched to parameters?
3. How can the caller use a function’s returned value?
4. What value does a call produce if the function prints a message but has no explicit return?
5. What happens to the rest of a function’s body when a return statement runs?