Chapter 9 - Boolean operators, and more about the return statement¶

1.1 The boolean operators¶

Let’s start by looking at an example that we used in a previous chapter: Mousetraps are sold online for 2.00 each plus .50 for shipping, with free shipping for orders of 30 or more. The logic that we used to calculate the shipping could be expressed like this (where num refers to the number ordered):

if num >= 30:
    shipping_cost = 0
else:
    shipping_cost = num * .50

Now suppose that shipping is also free for customers in zip code 50011. So before computing the shipping cost, we have to check the zip code. Assume that zip_code is a variable representing the zip code.

if num >= 30:
    shipping_cost = 0
else:
    if zip_code == 50010:
        shipping_cost = 0;
    else:
        shipping_cost = num * .50

This makes sense, but doesn’t it seem a bit strange that the line ``shipping_cost = 0``appears in two places?

After all, there are only two possibilities, either the shipping cost is zero, or else it’s num times 50 cents. It seems like what we really want to say is something like this:

So what goes in the blank? Logically we want to say “if num is at least 30 or the zip code is 50011, then the shipping is free”. Well, that’s the purpose of the or operator in Python. We can just write:

if num >= 30 or zip_code == 50010:
    shipping_cost = 0
else:
    shipping_cost = num * .50

To define exactly what the or operator does, let’s first summarize the possibilities and list the outcomes we intend. Each of the expressions can be either true or false, so there are four possibilities.

If num is at least 30 and the zip code is 50011, then shipping is free.

If num is at least 30 and the zip code isn’t 50011, then shipping is free.

If num is less than 30 but the zip code is 50011, then shipping is free.

Finally if num is less than 30 and the zip code isnt 50011, then shipping is not free.

This table tells us under what conditions this new expression should be true.

In fact, we can use the same table to define the or operator for any two boolean expressions A and B.

The table tells us that the new expression A or B is true if at least one or A or B is true. This is called the truth table for the or operator.

Let’s try another example. Suppose we have a function print_grade that prints the grade for a given score, but we first have to check that the score is between 0 and 100.

We could write something like this:

if score >= 0:
    if score<100
        print_grade(score)
    else:
        print("out of range")
else:
    print("out of range")

But again, it seems odd to have the same print statement appearing in two places. There are really only two possible outcomes, so we should be able to write something like this:

Now, what goes in the blank? We are trying to say “If score is above zero and less than 100, then print the grade.” That’s the purpose of the and keyword in Python:

if score >= 0 and score <= 100:
    print_grade(score)
else:
    print("out of range")

The new expression is true just when both of the original expressions are true. The and operator is defined with the following truth table.

The way that the and keyword is used corresponds to the way we use the word “and” in English. If someone says “My date was rich and handsome,” under what conditions is this a true statement? The guy might be rich, the guy might be handsome, but the statement “My date was rich and handsome” is only true when he’s both. Poor and handsome, or rich and ugly, just won’t cut it.

The way that the or keyword works is similar to the word “or” in English, but only when it is used in the “inclusive” sense. If you ask someone, “Are you crazy or just plain stupid?” and he says yes, it means he might be crazy, he might be stupid, but he might be both, and his answer “yes” would be true in all three cases. That’s the inclusive “or”. On the other hand, when the waiter asks you, “Would you like the soup or the salad?” he usually means you can choose a soup, OR a salad, but not both. That’s the exclusive “or”. The or keyword works like the inclusive “or” in English.

There is one more boolean operator, called not. Unlike the and and or operators, the not operator doesn’t combine two expressions. It applies to just one expression. Just like you can take a number put a minus sign in front of it, and get the negative of the number, you put not in front of any boolean expression to get the opposite value.

For example, the expression

not(x > 0)

has the same meaning as

x <= 0

Likewise, the expression

not(x == 100)

means the same thing as

x != 100

What about something like this?

not(score >= 0 and score <= 100)

You can read this as, “it is not the case that score is between 0 and 100”, which is the same as saying the score is less than 0 or is greater than 100:

score < 0 or score > 100

In all these examples, it was easy to rewrite the expression so that it doesn’t use the not operator. In some cases it is not so simple. Here is an example in which the not operator is extremely useful. We previously wrote a function is_divisible(a, b) that returns True when a is divisible by b and False otherwise. What if, given two values x and y, we want to say, “x is not divisible by y?” Well, one idea is to write a new function, but that is not always practical. But it is easy to simply write the expression

not is_divisible(x, y)

which has value True exactly when is_divisible(x, y) has value False.

The operators or, and, and not can be repeated or combined. For example, you could say “x is equal to 3, 5, or 7” using the expression

x == 3 or x == 5 or x == 7

If you wanted to write a condition that says

“either x is equal to y, or else y is strictly between x and x squared”,

it would look like this:

x == y or (x < y and x * x > y)

Technically we don’t need the parentheses above, but it is usually more clear just to include them rather than scratching your head over whether they are necessary. The rules for precedence are analogous to the rules for addition and multiplication, where or is like addition and and is like multiplication. The not operator has higher precedence that and and or, so when we write

not(score >= 0 and score <= 100)

the parentheses are definitely necessary.

1.2 More about the return statement and flow of control¶

There is something you have surely noticed about calling functions. Take another look at our first function, the function that prints a verse of the song “99 bottles.”

Think about the way the function call is altering the flow of control. When sing_verse is called, the interpreter goes to the sing_verse function and executes the statements it finds there. When the function ends, control returns to the exact point where the function was called, and execution continues from that point.

We have used return statements in our value-returning functions in order to specify the value of the function. It turns out that a return statement has another purpose too: to actually cause the flow of control to literally return to the point where the function was called. For a function that doesn’t return a value, this happens automatically at the end of the function, as in sing_verse above. In the value-returning functions we have written so far, we have used a single return statement at the end of the function body, which is usually a good approach.

It is also possible to put return statements in the middle of the function body, and you should know how this works. Whenever the interpreter encounters a return statement, it stops executing the statements in the function body right then and there, and returns control to the point at which the function was called.

As an example let’s look again at the letter_grade function we wrote previously.

Notice that there are four alternative actions (assigning a letter to the grade variable) and we’re using the elif so that exactly one of them will execute. Here is another way the function could be written.

How does this work? Let’s see what happens if the score is 85. Is 85 above 90? No, so the if-block, that is, the line return "A", is skipped. Is 85 above 80? Yes, so we execute the if-block, which contains the line return "B". The return statement does two things here: it gives the function the value “B”, and it causes the interpreter to immediately return to where the function was called. That is, the rest of the statements are not executed at all. Try this with codelens.

For non-value-returning functions, it’s possible to use a return statement all by itself, that is, without an expression following it. This causes the interpreter to immediately return to where the function was called, but without returning a value. That is, the statement

return

is exactly the same as

return None

If a function doesn’t return a value, you normally don’t need a return statement. Returning from a function happens automatically whenever the interpreter reaches the last statement in the function. When you write a function with multiple returns, you have to be careful to make sure there’s a return statement along every possible path. For example consider this simple function for determining the maximum of two numbers, which contains a subtle error.

Try out the output. None? What happened? If first and second are the same, then neither one of the return statements will be executed. When control reaches the end of the function, it returns automatically with the value None.

Programming with multiple return statements is convenient sometimes and we will do it occasionally, especially when we start programming with loops. But for now you will probably agree that our first version of letter_grade, using elif was much easier to understand than the version above with multiple return statements. Unless there is a good reason to do otherwise, you should use a single return statement at the end of the function body.