Building Functions with Lists

Chapter 4 explained what happens when a function receives a list. This chapter concentrates on the algorithms inside such functions: searches, empty inputs, and functions built from other functions.

Familiar Loops Can Live Inside Functions

The selected-count pattern from Part 2 changes very little inside a function:

The function receives the list and boundary through parameters, calculates a count, and returns it. It does not decide how the result should be displayed.

A return Ends the Current Call

Chapter 3 established that return ends a function call immediately. Its position is especially important inside a loop:

def contains_negative(values):
    for value in values:
        if value < 0:
            return True
        else:
            return False

This function examines only the first item. On the first iteration, one of the two returns always runs, so the call ends before the loop can reach later values.

A correct search delays the negative conclusion:

def contains_negative(values):
    for value in values:
        if value < 0:
            return True

    return False

The function may return True as soon as one negative value is found. It can return False only after the loop has checked every value without finding one.

For an empty list, the loop runs zero times and execution reaches return False. That matches the requirement: an empty list contains no negative value.

First, trace several return placements:

Then, write a function of your own for searching a list:

contains_signal(["clear", "echo", "ready"], "echo")  # returns True
contains_signal(["clear", "ready"], "echo")          # returns False
contains_signal([], "echo")                            # returns False

Empty Inputs Need Deliberate Behavior

Some list functions have a natural result for an empty list. A count or total can return 0, and a search can return False.

Other calculations need a design decision:

def largest_value(values):
    largest = values[0]

    for value in values:
        if value > largest:
            largest = value

    return largest

This function cannot use index 0 when values is empty. Possible designs include returning a special value or requiring a nonempty input. Returning 0 only to avoid the problem would be misleading: zero is not the largest member of an empty list.

A precondition states something that must be true before a function is called. For the version above, the precondition could be “values is nonempty.” The caller must then check the empty case before calling it.

Use the stated requirement to decide whether the function accepts an empty list and what it should do with one. Chapter 9 looks more closely at writing these requirements.

Functions Can Use Other Functions

Small functions can become building blocks:

def total_values(values):
    total = 0

    for value in values:
        total = total + value

    return total


def average_value(values):
    total = total_values(values)
    return total / len(values)

average_value delegates summing to total_values and uses the returned number. This is function composition: one function call supplies information used by another calculation.

This particular average_value requires a nonempty list. Its caller must handle the empty case because an average does not exist for no values.

The next exercise combines several list calculations. Work on one function at a time and test ordinary cases. Test empty input where the contract accepts it; use nonempty lists for the average and summary functions. Then connect the returned results:

summarize_route([4, 7, 3, 10], 7)

[24, 6.0, 2]

The program below is incomplete - the function is missing its counting step. Add it so the program prints the correct count.

3

Check Your Understanding

1. Why does count_long_words receive both a list and a minimum length as parameters?
2. How can placing return inside a loop prevent later items from being checked?
3. How should a function’s requirements guide its behavior when the list is empty?
4. How can one function use a value returned by another function?