Chapter 8 Conditional execution

A second form of the if statement is “alternative execution”, in which there are two possibilities and the condition determines which one runs. The syntax looks like this:

If the remainder when x is divided by 2 is 0, then we know that x is even, and the program displays an appropriate message. If the condition is false, the second set of statements runs. Since the condition must be true or false, exactly one of the alternatives will run. The alternatives are called branches, because they are branches in the flow of execution.

Sometimes there are more than two possibilities and we need more than two branches. One way to express a computation like that is a chained conditional:

elif is an abbreviation of “else if”. Again, exactly one branch will run. There is no limit on the number of elif statements. If there is an else clause, it has to be at the end, but there doesn’t have to be one.

Each condition is checked in order. If the first is false, the next is checked, and so on. If one of them is true, the corresponding branch runs and the statement ends. Even if more than one condition is true, only the first true branch runs.

One conditional can also be nested within another. We could have written the example in the previous section like this:

The outer conditional contains two branches. The first branch contains a simple statement. The second branch contains another if statement, which has two branches of its own. Those two branches are both simple statements, although they could have been conditional statements as well.

Although the indentation of the statements makes the structure apparent, nested conditionals become difficult to read very quickly. It is a good idea to avoid them when you can.

Logical operators often provide a way to simplify nested conditional statements. For example, we can rewrite the following code using a single conditional:

The print statement runs only if we make it past both conditionals, so we can get the same effect with the and operator:

For this kind of condition, Python provides a more concise option:

Functions can return booleans, which is often convenient for hiding complicated tests inside functions.

This is so common that it is given a special name: a function that returns a boolean is often called a predicate, or a predicate function.

For example:

It is common to give boolean functions names that sound like yes/no questions; is_divisible returns either True or False to indicate whether x is divisible by y.

Here is an example:

The result of the == operator is a boolean, so we can write the function more concisely by returning it directly:

Boolean functions are often used in conditional statements:

It might be tempting to write something like:

But the extra comparison is unnecessary.

As an exercise, write a function is_between(x, y, z) that returns True if $x\le y\le z$ or False otherwise.

There are many built-in predicates in Python. One interesting one is isinstance. We can use this to check the type of a value, and even to treat different types differently:

We might be tempted to use the type function in a situation like this. But this is not a good idea. Python is an object oriented programming language, and supports inheritance; this means that for example something could be “a kind of int” instead of literally being an int. The type function ignores inheritance, while isinstance works with it in a sensible manner.

When a syntax or runtime error occurs, the error message contains a lot of information, but it can be overwhelming. The most useful parts are usually:

• •

  What kind of error it was, and

• •

  Where it occurred.

Syntax errors are usually easy to find, but there are a few gotchas. Whitespace errors can be tricky because spaces and tabs are invisible and we are used to ignoring them.

In this example, the problem is that the second line is indented by one space. But the error message points to y, which is misleading. In general, error messages indicate where the problem was discovered, but the actual error might be earlier in the code, sometimes on a previous line.

The same is true of runtime errors. Suppose you are trying to compute a signal-to-noise ratio in decibels. The formula is $SN{R}_{db}=10{\log }_{10}(P_{signal}/P_{noise})$. In Python, you might write something like this:

When you run this program, you get an exception:

The error message indicates line 5, but there is nothing wrong with that line. To find the real error, it might be useful to print the value of ratio, which turns out to be 0. The problem is in line 4, which uses floor division instead of floating-point division.

You should take the time to read error messages carefully, but don’t assume that everything they say is correct.

boolean expression:

An expression whose value is either True or False.

relational operator:

One of the operators that compares its operands: ==, !=, >, <, >=, and <=.

logical operator:

One of the operators that combines boolean expressions: and, or, and not.

conditional statement:

A statement that controls the flow of execution depending on some condition.

condition:

The boolean expression in a conditional statement that determines which branch runs.

compound statement:

A statement that consists of a header and a body. The header ends with a colon (:). The body is indented relative to the header.

branch:

One of the alternative sequences of statements in a conditional statement.

chained conditional:

A conditional statement with a series of alternative branches.

nested conditional:

A conditional statement that appears in one of the branches of another conditional statement.

return statement:

A statement that causes a function to end immediately and return to the caller.