Let’s start with ==. The expression p == q is True just when p and q both have the same true value—that is, when p and q are both True or both False. The expression p != q tests if p and q are not the same, and returns True just when they have different values.

The Boolean expression p and q is True just when both p is True and q is True. In every other case it is False. The fifth column of Table 4.1 summarizes each case.

The Boolean expression p or q is True exactly when p is True or q is True, or when both are True. This is summarized in the sixth column of Table 4.1. It’s important to realize that p or q is true when both p and q are True; Python’s or is sometimes called inclusive-or, because it includes the case when both are True.

Finally, the Boolean expression not p is True when p is False, and False when p is True. It essentially flips the value of the variable.

Let’s look at a few examples:

>>> False == False
True
>>> True and False
False
>>> False or False
False
>>> not True
False

Python uses an internal version of Table 4.1 to evaluate Boolean expressions.

Since Boolean expressions are used to control both if-statements and loops, it is important to understand how they are evaluated. Just as with arithmetic expressions, Boolean expressions use both brackets and operator precedence to specify the order in which the subparts of the expression are evaluated.

The definition of the logical operators given in Table 4.1 is the standard definition you would find in any logic textbook. However, like most modern programming languages, Python uses a technique called short-circuit evaluation to speed up the evaluation of some Boolean expressions.

Consider the Boolean expression False and X, where X is any Boolean expression; assume it’s a big, nasty expression that would take you a few seconds to evaluate. It turns out that no matter the value of X, no matter whether X is True or X is False, the entire expression is False. The reason is that the initial False makes the whole and-expression False. In other words, the value of the expression False and X does not depend on X—it is always False. In such cases, Python does not evaluate X at all—it simply stops and returns the value False. This can speed up the evaluation of Boolean expressions.

Similarly, Boolean expressions of the form True or X are always True, no matter the value of X. The precise rules for how Python does short-circuiting are given in Table 4.3.

Most of the time you can ignore short-circuiting and just reap its performance benefits. However, it is useful to remember that Python does this, since every once in a while it could be the source of a subtle bug.

Suppose you are writing a password-checking program. You ask users to enter their password, and if it is correct, you log them in to their account. If it is not correct, then you tell them they’ve entered the wrong password. A simple version of that program is this:

# password1.py
pwd = input('What is the password? ')

if pwd == 'apple':  # note use of ==
                    # instead of =
    print('Logging on ...')
else:
    print('Incorrect password.')

print('All done!')

It’s pretty easy to read this program: If the string that pwd labels is 'apple', then a login message is printed. But if pwd is anything other than 'apple', the message incorrect password is printed.

An if-statement always begins with the keyword if. It is then (always) followed by a Boolean expression called the if-condition, or just condition for short. After the if-condition comes a colon (:). As we will see, Python uses the : token to mark the end of conditions in if-statements, loops, and functions.

Everything from the if to the : is referred to as the if-statement header. If the condition in the header evaluates to True, then the statement print('Logging on ...') is immediately executed, and print('Incorrect password.') is skipped and never executed.

If the condition in the header evaluates to False, then print('Logging on ...') is skipped, and only the statement print('Incorrect password.') is executed.

In all cases, the final print('All done!') statement is executed.

The general structure of an if/else-statement is shown in Figure 4.1.

Figure 4.1. This flow chart shows the general format and behavior of an if/else-statement. The code blocks can consist of any number of Python statements (even other if-statements!).

An if/elif-statement is a generalized if-statement with more than one condition. It is used for making complex decisions. For example, suppose an airline has the following “child” ticket rates: Kids 2 years old or younger fly for free, kids older than 2 but younger than 13 pay a discounted child fare, and anyone 13 years or older pays a regular adult fare. The following program determines how much a passenger should pay:

# airfare.py
age = int(input('How old are you? '))
if age <= 2:
    print(' free')
elif 2 < age < 13:
    print(' child fare)
else:
    print('adult fare')

After Python gets age from the user, it enters the if/elif-statement and checks each condition one after the other in the order they are given. So first it checks if age is less than 2, and if so, it indicates that the flying is free and jumps out of the elif-condition. If age is not less than 2, then it checks the next elif-condition to see if age is between 2 and 13. If so, it prints the appropriate message and jumps out of the if/elif-statement. If neither the if-condition nor the elif-condition is True, then it executes the code in the else-block.

Python has one more logical operator that some programmers like (and some don’t!). It’s essentially a shorthand notation for if-statements that can be used directly within expressions. Consider this code:

food = input("What's your favorite food? ")
reply = 'yuck' if food == 'lamb' else 'yum'

The expression on the right-hand side of = in the second line is called a conditional expression, and it evaluates to either 'yuck' or 'yum'. It’s equivalent to the following:

food = input("What's your favorite food? ")
if food == 'lamb':
   reply = 'yuck'
else:
   reply = 'yum'

Conditional expressions are usually shorter than the corresponding if/else-statements, although not quite as flexible or easy to read. In general, you should use them when they make your code simpler.

The basic for-loop repeats a given block of code some specified number of times. For example, this snippet of code prints the numbers 0 to 9 on the screen:

# count10.py
for i in range(10):
    print(i)

The first line of a for-loop is called the for-loop header. A for-loop always begins with the keyword for. After that comes the loop variable, in this case i. Next is the keyword in, typically (but not always) followed by range(n) and a terminating : token. A for-loop repeats its body, the code block underneath it, exactly n times.

Each time the loop executes, the loop variable i is set to be the next value. By default, the initial value of i is 0, and it goes up to n - 1 (not n!) by ones. Starting numbering at 0 is fairly common in programming, although it is surprising at first.

If you want to change the starting value of the loop, add a starting value to range:

for i in range(5, 10):
    print(i)

This prints the numbers from 5 to 9.

Thinking about for-loops as printing a list of numbers is a good way to learn what they do. We will see many more examples of for-loops throughout this book.

The second kind of Python loop is a while-loop. Consider this program:

# while10.py
i = 0
while i < 10:
    print(i)
    i = i + 1  # add 1 to i

This prints out the numbers from 0 to 9 on the screen. It is noticeably more complicated than a for-loop, but it is also more flexible.

The while-loop itself begins on the line beginning with the keyword while; this line is called the while-loop header, and the indented code underneath it is called the while-loop body. The header always starts with while and is followed by the while-loop condition. This condition is a Boolean expression that returns True or False.

The flow of control through a while-loop goes like this: First, Python checks if the loop condition is True or False. If it’s True, it executes the body; if it’s False, it skips over the body (that is, it jumps out of the loop) and runs whatever statements appear afterward. When the condition is True, the body is executed, and then Python checks the condition again. As long as the loop condition is True, Python keeps executing the loop. Figure 4.2 shows a flow chart for this program.

Figure 4.2. This is a flow chart for code that counts from 0 to 9. Notice that when the loop condition is False (that is, the no branch is taken in the decision box), the arrow does not go into a box. That’s because in our sample code there is nothing after the while-loop.

The very first line of the sample program is i = 0, and in the context of a loop it is known as an initialization statement, or an initializer. Unlike with for-loops, which automatically initialize their loop variable, it is the programmer’s responsibility to give initial values to any variables used by a while-loop.

The last line of the loop body is i = i + 1. As it says in the source code comment, this line causes i to be incremented by 1. Thus, i increases as the loop executes, which guarantees that the loop will eventually stop. In the context of a while-loop, this line is called an increment, or incrementer, since its job is to increment the loop variable.

The general form of a while-loop is shown in the flow chart of Figure 4.3.

Figure 4.3. A flow chart for the general form of a while-loop. Note that the incrementer is not shown explicitly: It is embedded somewhere in body_block often (but not always) at the end of that block.

Even though almost all while-loops need an initializer and an incrementer, Python does not require that you include them. It is entirely up to you, the programmer, to remember these lines. Even experienced programmers find that while-loop initializers and incrementers are a common source of errors.

Factorials are numbers of the form 1 × 2 × 3 × ... × n, and they tell you how many ways n objects can be arranged in a line. For example, the letters ABCD can be arranged in 1 × 2 × 3 × 4 = 24 different ways. Here’s one way to calculate factorials using a for-loop:

# forfact.py
n = int(input('Enter an integer >= 0: '))
fact = 1
for i in range(2, n + 1):
    fact = fact * i
print(str(n) + ' factorial is ' + str(fact))

Here’s another way to do it using a while-loop:

# whilefact.py
n = int(input('Enter an integer >= 0: '))
fact = 1
i = 2
while i <= n:
    fact = fact * i
    i = i + 1
print(str(n) + ' factorial is ' + str(fact))

Both of these programs behave the same from the user’s perspective, but the internals are quite different. As is usually the case, the while-loop version is a little more complicated than the for-loop version.

The following programs ask the user to enter some numbers, and then return their sum. Here is a version using a for-loop:

# forsum.py
n = int(input('How many numbers to sum? '))
total = 0
for i in range(n):
    s = input('Enter number ' + str(i + 1) + ': ')
    total = total + int(s)
print('The sum is ' + str(total))

Here’s a program that does that same thing using a while-loop:

# whilesum.py
n = int(input('How many numbers to sum? '))
total = 0
i = 1
while i <= n:
    s = input('Enter number ' + str(i) + ': ')
    total = total + int(s)
    i = i + 1
print('The sum is ' + str(total))

Again, the while-loop version is a little more complex than the for-loop version.

Now here’s something that can’t be done with the for-loops we’ve introduced so far. Suppose we want to let users enter a list of numbers to be summed without asking them ahead of time how many numbers they have. Instead, they just type the string 'done' when they have no more numbers to add. Here’s how to do it using a while-loop:

# donesum.py
total = 0
s = input('Enter a number (or 'done'): ')
while s != 'done':
    num = int(s)
    total = total + num
    s = input('Enter a number (or "done"): ')
print('The sum is ' + str(total))

The idea here is to keep asking users to enter a number, quitting only when they enter 'done'. The program doesn’t know ahead of time how many times the loop body will be executed.

Notice a few more details: