Elements of Flow Control [Python]

Flow control statements often start with a part called the condition, and all are followed by a block of code called the clause. Before you learn about Python’s specific flow control statements, I’ll cover what a condition and a block are.

Conditions

The Boolean expressions you’ve seen so far could all be considered conditions, which are the same thing as expressions; condition is just a more specific name in the context of flow control statements. Conditions always evaluate down to a Boolean value, True or False. A flow control statement decides what to do based on whether its condition is True or False, and almost every flow control statement uses a condition.

Blocks of Code

Lines of Python code can be grouped together in blocks. You can tell when a block begins and ends from the indentation of the lines of code. There are three rules for blocks.

1. Blocks begin when the indentation increases.
2. Blocks can contain other blocks.
3. Blocks end when the indentation decreases to zero or to a containing block’s indentation.

Blocks are easier to understand by looking at some indented code, so let’s find the blocks in part of a small game program, shown here:

if name == 'Mary':

print('Hello Mary')if password == 'swordfish':

print('Access granted.')else:

print('Wrong password.')

The first block of code u starts at the line print('Hello Mary') and contains all the lines after it. Inside this block is another block v, which has only a single line in it: print('Access Granted.'). The third block w is also one line long: print('Wrong password.').

Program Execution

In the previous chapter’s hello.py program, Python started executing instructions at the top of the program going down, one after another. The program execution (or simply, execution) is a term for the current instruction being executed. If you print the source code on paper and put your finger on each line as it is executed, you can think of your finger as the program execution.

Not all programs execute by simply going straight down, however. If you use your finger to trace through a program with flow control statements, you’ll likely find yourself jumping around the source code based on conditions, and you’ll probably skip entire clauses.

Flow Control Statements

Now, let’s explore the most important piece of flow control: the statements themselves. The statements represent the diamonds you saw in the flowchart in Picture, and they are the actual decisions your programs will make. if Statements The most common type of flow control statement is the if statement. An if statement’s clause (that is, the block following the if statement) will execute if the statement’s condition is True. The clause is skipped if the condition is False.

In plain English, an if statement could be read as, “If this condition is true, execute the code in the clause.” In Python, an if statement consists of the following:

• The if keyword
• A condition (that is, an expression that evaluates to True or False)
• A colon
• Starting on the next line, an indented block of code (called the if clause)

For example, let’s say you have some code that checks to see whether someone’s name is Alice. (Pretend name was assigned some value earlier.)

if name == 'Alice':print('Hi, Alice.')

All flow control statements end with a colon and are followed by a new block of code (the clause). This if statement’s clause is the block with print('Hi, Alice.'). The Figure below will shows what a flowchart of this code would look like.

The flowchart for an if statement

else Statements

An if clause can optionally be followed by an else statement. The else clause is executed only when the if statement’s condition is False. In plain English, an else statement could be read as, “If this condition is true, execute this code. Or else, execute that code.” An else statement doesn’t have a condition, and in code, an else statement always consists of the following:

• The else keyword
• A colon
• Starting on the next line, an indented block of code (called the else clause)

Returning to the Alice example, let’s look at some code that uses an else statement to offer a different greeting if the person’s name isn’t Alice.

if name == 'Alice':print('Hi, Alice.')else:print('Hello, stranger.')

The flowchart for an else statement

el if Statements

While only one of the if or else clauses will execute, you may have a case where you want one of many possible clauses to execute. The elif statement is an “else if” statement that always follows an if or another elif statement.

It provides another condition that is checked only if any of the previous conditions were False. In code, an elif statement always consists of the following:

• The elif keyword
• A condition (that is, an expression that evaluates to True or False)
• A colon
• Starting on the next line, an indented block of code (called the elif clause)

Let’s add an elif to the name checker to see this statement in action.

if name == 'Alice':print('Hi, Alice.')elif age < 12:print('You are not Alice, kiddo.')

This time, you check the person’s age, and the program will tell them something different if they’re younger than 12. You can see the flowchart for this in the picture below

The flowchart for an elif statement

The elif clause executes if age < 12 is True and name == 'Alice' is False. However, if both of the conditions are False, then both of the clauses are skipped. It is not guaranteed that at least one of the clauses will be executed.

When there is a chain of elif statements, only one or none of the clauses will be executed. Once one of the statements’ conditions is found to be True, the rest of the elif clauses are automatically skipped. For example, open a new file editor window and enter the following code, saving it as vampire.py:

1. if name == 'Alice':
2.     print('Hi, Alice.')
3. elif age < 12:
4.     print('You are not Alice, kiddo.')
5. elif age > 2000:
6.     print('Unlike you, Alice is not an undead, immortal vampire.')
7. elif age > 100:
8.     print('You are not Alice, grannie.')

Here I’ve added two more elif statements to make the name checker greet a person with different answers based on age. The Figure shows the flowchart for this.

The flowchart for multiple elif statements in the vampire.py program

The order of the elif statements does matter, however. Let’s rearrange them to introduce a bug. Remember that the rest of the elif clauses are automatically skipped once a True condition has been found, so if you swap around some of the clauses in vampire.py, you run into a problem. Change the code to look like the following, and save it as vampire2.py:

1. if name == 'Alice':
2.     print('Hi, Alice.')
3. elif age < 12:
4.     print('You are not Alice, kiddo.')
6. elif age > 100:
7.     print('You are not Alice, grannie.')
8. elif age > 2000:
9.     print('Unlike you, Alice is not an undead, immortal vampire.')

Say the age variable contains the value 3000 before this code is executed.

You might expect the code to print the string 'Unlike you, Alice is not an undead, immortal vampire.'. However, because the age > 100 condition is True (after all, 3000 is greater than 100) u, the string 'You are not Alice, grannie.' is printed, and the rest of the elif statements are automatically skipped.

Remember, at most only one of the clauses will be executed, and for elif statements, the order matters!

The Picture below will shows the flowchart for the previous code. Notice how the diamonds for age > 100 and age > 2000 are swapped.

Optionally, you can have an else statement after the last elif statement. In that case, it is guaranteed that at least one (and only one) of the clauses will be executed. If the conditions in every if and elif statement are False, then the else clause is executed. For example, let’s re-create the Alice program
to use if, elif, and else clauses.

1. if name == 'Alice':
2.     print('Hi, Alice.')
3. elif age < 12:
4.     print('You are not Alice, kiddo.')
5. else:
6.     print('You are neither Alice nor a little kid.')

In plain English, this type of flow control structure would be, “If the first condition is true, do this. Else, if the second condition is true, do that.

Otherwise, do something else.” When you use all three of these statements together, remember these rules about how to order them to avoid bugs like the one in The Figure. First, there is always exactly one if statement. Any elif statements you need should follow the if statement. Second, if you want to be sure that at least one clause is executed, close the structure with an else statement.

The flowchart for the vampire2.py program. The crossed-out path will logically never happen, because if age were greater than 2000, it would have already been greater than 100.

Flowchart for the previous littleKid.py program

While Loop Statements 

You can make a block of code execute over and over again with a while statement. The code in a while clause will be executed as long as the while statement’s condition is True. In code, a while statement always consists of the following:

• The while keyword
• A condition (that is, an expression that evaluates to True or False)
• A colon
• Starting on the next line, an indented block of code (called the while clause)

You can see that a while statement looks similar to an if statement. The difference is in how they behave. At the end of an if clause, the program execution continues after the if statement. But at the end of a while clause, the program execution jumps back to the start of the while statement. The while clause is often called the while loop or just the loop.

Let’s look at an if statement and a while loop that use the same condition and take the same actions based on that condition. Here is the code with an if statement:

These statements are similar—both if and while check the value of spam, and if it’s less than five, they print a message. But when you run these two code snippets, something very different happens for each one. For the if statement, the output is simply "Hello, world.". But for the while statement, it’s "Hello, world." repeated five times! Take a look at the flowcharts for these two pieces of code, The Figures below, to see why this happens.

The flowchart for the while statement code

The code with the if statement checks the condition, and it prints Hello, world. only once if that condition is true. The code with the while loop, on the other hand, will print it five times. It stops after five prints because the integer in spam is incremented by one at the end of each loop iteration, which means that the loop will execute five times before spam < 5 is False. In the while loop, the condition is always checked at the start of each iteration (that is, each time the loop is executed). If the condition is True, then the clause is executed, and afterward, the condition is checked again. The first time the condition is found to be False, the while clause is skipped.

An Annoying while Loop

Here’s a small example program that will keep asking you to type, literally, your name. Select File > New Window to open a new file editor window, enter the following code, and save the file as yourName.py:

1. name = ''
2. v while name != 'your name':
3.     print('Please type your name.')
4.     w name = input()
5. x print('Thank you!')

First, the program sets the name variable (line)1 to an empty string. This is so that the name != 'your name' condition will evaluate to True and the program execution will enter the while loop’s clause (line)2.

The code inside this clause asks the user to type their name, which is assigned to the name variable (line) 3. Since this is the last line of the block, the execution moves back to the start of the while loop and reevaluates the condition. If the value in name is not equal to the string 'your name', then the condition is True, and the execution enters the while clause again. But once the user types your name, the condition of the while loop will be 'your name' != 'your name', which evaluates to False. The condition is now False, and instead of the program execution reentering the while loop’s clause, it skips past it and continues running the rest of the program x. The Figure shows a flowchart for the yourName.py program (line) 4.

A flowchart of the yourName.py program

Now, let’s see yourName.py in action. Press F5 to run it, and enter something other than your name a few times before you give the program what it wants.

1. Please type your name.
2. Al
3. Please type your name.
4. Albert
5. Please type your name.
6. %#@#%*(^&!!!
7. Please type your name.
8. your name
9. Thank you!

If you never enter your name, then the while loop’s condition will never be False, and the program will just keep asking forever. Here, the input() call lets the user enter the right string to make the program move on. In other programs, the condition might never actually change, and that can be a problem. Let’s look at how you can break out of a while loop.

break Statements

There is a shortcut to getting the program execution to break out of a while loop’s clause early. If the execution reaches a break statement, it immediately exits the while loop’s clause. In code, a break statement simply contains the break keyword.

Pretty simple, right? Here’s a program that does the same thing as the previous program, but it uses a break statement to escape 

1. while True:
2.     print('Please type your name.')
3.     name = input()
4.     if name == 'your name':
5.         break
6. print('Thank you!')

The first line 1 creates an infinite loop; it is a while loop whose condition is always True. (The expression True, after all, always evaluates down to the value True.) The program execution will always enter the loop and will exit it only when a break statement is executed. (An infinite loop that never exits is a common programming bug.)

Just like before, this program asks the user to type your name (line)2. Now, however, while the execution is still inside the while loop, an if statement gets executed (line)3 to check whether name is equal to your name. If this condition is True, the break statement is run (line)4, and the execution moves out of the loop to print('Thank you!') (line)5. Otherwise, the if statement’s clause with the break statement is skipped, which puts the execution at the end of the while loop. At this point, the program execution jumps back to the start of the while statement (line)1 to recheck the condition. Since this condition is merely the True Boolean value, the execution enters the loop to ask the user to type your name again. See Figure 2-12 for the flowchart of this program.

Run yourName2.py, and enter the same text you entered for yourName.py. The rewritten program should respond in the same way as the original.

The flowchart for the yourName2.py program with an infinite loop. Note

that the X path will logically never happen because the loop condition is always True.

Continue Statements

Like break statements, continue statements are used inside loops. When the program execution reaches a continue statement, the program execution immediately jumps back to the start of the loop and reevaluates the loop’s condition. (This is also what happens when the execution reaches the end

of the loop.)

Trapp ed in an Infinite Loop?

If you ever run a program that has a bug causing it to get stuck in an infinite

loop, press ctrl-C. This will send a KeyboardInterrupt error to your program

and cause it to stop immediately. To try it, create a simple infinite loop in the

file editor, and save it as infiniteloop.py.

1. while True:
2. print('Hello world!')

When you run this program, it will print Hello world! to the screen forever,

because the while statement’s condition is always True. In IDLE’s interactive shell

window, there are only two ways to stop this program: press ctrl-C or select

Shell4Restart Shell from the menu. ctrl-C is handy if you ever want to terminate

your program immediately, even if it’s not stuck in an infinite loop.

Let’s use continue to write a program that asks for a name and password. Enter the following code into a new file editor window and save the program as swordfish.py.

1. while True:
2. print('Who are you?')
3. name = input()
4.     if name != 'Joe':
5.     continue
6.         print('Hello, Joe. What is the password? (It is a fish.)')
7.     password = input()
8.     if password == 'swordfish':
9.         break
10. print('Access granted.')

If the user enters any name besides Joe (line)4, the continue statement (line)5 causes the program execution to jump back to the start of the loop. When it reevaluates the condition, the execution will always enter the loop, since the condition is simply the value True. Once they make it past that if statement, the user is asked for a password (line)7. If the password entered is swordfish, then the break statement (line)9 is run, and the execution jumps out of the while loop to print Access granted (line)10. Otherwise, the execution continues to the end of the while loop, where it then jumps back to the start of the loop. See the Figure below for this program’s flowchart.

A flowchart for swordfish.py. The X path will logically never happen because the loop

condition is always True.

“Truthy” and “Fa lsey” Values

There are some values in other data types that conditions will consider equivalent to True and False. When used in conditions, 0, 0.0, and '' (the empty string) are considered False, while all other values are considered True. For example, look at the following program:

1. name = ''
2. while not name:  --> 1
3. print('Enter your name:')
4. name = input()
5. print('How many guests will you have?')
6. numOfGuests = int(input())
7. if numOfGuests:   --> 2
8. print('Be sure to have enough room for all your guests.')    -->3
9. print('Done')

If the user enters a blank string for name, then the while statement’s condition will be True 1, and the program continues to ask for a name. If the value for numOfGuests is not 0 2, then the condition is considered to be True, and the program will print a reminder for the user 3.

You could have typed not name != '' instead of not name, and numOfGuests != 0 instead of numOfGuests, but using the truthy and falsey values can make your code easier to read.

Run this program and give it some input. Until you claim to be Joe, it shouldn’t ask for a password, and once you enter the correct password, it should exit.

1. Who are you?
2. I'm fine, thanks. Who are you?
3. Who are you?
4. Joe
5. Hello, Joe. What is the password? (It is a fish.)
6. Mary
7. Who are you?
8. Joe
9. Hello, Joe. What is the password? (It is a fish.)
10. swordfish
11. Access granted.

for Loops and the range() Function

The while loop keeps looping while its condition is True (which is the reason for its name), but what if you want to execute a block of code only a certain number of times? You can do this with a for loop statement and the range() function.

In code, a for statement looks something like for i in range(5): and always includes the following:

• The for keyword
• A variable name
• The in keyword
• A call to the range() method with up to three integers passed to it A colon
• Starting on the next line, an indented block of code (called the for clause)

Let’s create a new program called fiveTimes.py to help you see a for loop in action.

1. print('My name is')
2. for i in range(5):
3.     print('Jimmy Five Times (' + str(i) + ')')

The code in the for loop’s clause is run five times. The first time it is run, the variable i is set to 0. The print() call in the clause will print Jimmy Five Times (0). After Python finishes an iteration through all the code inside the for loop’s clause, the execution goes back to the top of the loop, and the for statement increments i by one. This is why range(5) results in five iterations through the clause, with i being set to 0, then 1, then 2, then 3, and then 4. The variable i will go up to, but will not include, the integer passed to range(). The Figure shows a flowchart for the fiveTimes.py program.

The flowchart for fiveTimes.py

When you run this program, it should print Jimmy Five Times followed by the value of i five times before leaving the for loop.

My name is

Jimmy Five Times (0)

Jimmy Five Times (1)

Jimmy Five Times (2)

Jimmy Five Times (3)

Jimmy Five Times (4)

Note: You can use break and continue statements inside for loops as well. The continue
statement will continue to the next value of the for loop’s counter, as if the program
execution had reached the end of the loop and returned to the start. In fact, you can
use continue and break statements only inside while and for loops. If you try to use
these statements elsewhere, Python will give you an error.

As another for loop example, consider this story about the mathematician Karl Friedrich Gauss. When Gauss was a boy, a teacher wanted to give the class some busywork. The teacher told them to add up all the numbers from 0 to 100. Young Gauss came up with a clever trick to figure out the answer in a few seconds, but you can write a Python program with a for loop to do this calculation for you.

1 total = 0

2 for num in range(101):

3 total = total + num

4 print(total)

The result should be 5,050. When the program first starts, the total variable is set to 0 (line)1. The for loop (line)2 then executes total = total + num (line)3 100 times. By the time the loop has finished all of its 100 iterations, every integer from 0 to 100 will have been added to total. At this point, total is

printed to the screen (line)4. Even on the slowest computers, this program takes less than a second to complete.

(Young Gauss figured out that there were 50 pairs of numbers that added up to 100: 1 + 99, 2 + 98, 3 + 97, and so on, until 49 + 51. Since 50 × 100 is 5,000, when you add that middle 50, the sum of all the numbers from 0 to 100 is 5,050. Clever kid!)

An Equivalent while Loop

You can actually use a while loop to do the same thing as a for loop; for loops are just more concise. Let’s rewrite fiveTimes.py to use a while loop equivalent of a for loop.

print('My name is')

i = 0

while i < 5:

        print('Jimmy Five Times (' + str(i) + ')')

        i = i + 1

Share this post