x = 1
while x < 11:
    print(x)
    x = x + 1   # See assignment operator note below

1
2
3
4
5
6
7
8
9
10

Flowchart Details:

• Compare the flowchart to the Code Details.
• Note that the flowchart presents a visual representation of the code solution and visa versa.
• The flowchart includes a Start and End to depict the entire execution path of the code solution. In larger programs, the execution path would be larger and the loop would be only one segment of the larger codebase.

Assignment Operator Note: In the code solution for Example 1 above, I wrote x = x + 1 to increment the value of x. While this works, it is more common to use a more abbreviated form using the Addition Assignment Operator like this:

x += 1

This performs the same operation as x = x + 1 and is more efficient. Python supports numerous Assignment Operators, which you can review on the Operators Reference Materials ↗ page.

10
9
8
7
6
5
4
3
2
1

x = 10
while x > 0:
    print(x)
    x -= 1

1
3
5
7
9

2
4
5
6
10

# Odd integers
x = 1
while x < 11:
    print(x)
    x = x + 2

# Even integers
x = 2
while x < 11:
    print(x)
    x = x + 2

Example 2

Problem: Prompt the user to enter integers. Accumulate the integers they enter until they indicate they are finished entering integers. Then print a report of how many integers they entered, the sum of all the integers, and the average of their integers.

This problem demonstrates several key uses of while loops, including giving users control over entering data, accumulating data values and producing summaries of that data, and handling numerous variables through a repetition structure.

Solution:

user_int = 0
counter = 0
int_sum = 0
print("-" * 50)
print("Enter a series of integers and")
print("receive a summary report.")
print("-" * 50)
print("When finished, press Enter")
print("at the prompt with no integer.")
print("-" * 50)
user_int = input("Enter your first integer: ")
while user_int != "":
   int_sum = int_sum + int(user_int)
   counter += 1
   user_int = input("Enter your next integer: ")
print("-" * 50)
print("Summary Report")
print("-" * 50)
if counter > 0:
   print("You entered " + str(counter) + " integers.")
   print("The sum of your integers is " + str(int_sum) + ".")
   print("The average of your integers is " + str(int_sum / counter) + ".")
else:
   print("You entered no integers.")
print("-" * 50)

This is a more substantial program than we have seen thus far, so take your time and work through the following code details that explain each line of this program.
Code Details:

• As indicated in the problem description, we will use several variables in this program.
• The variable user_int initialized on Line 1 to 0, will hold each integer value entered by the user.
• The variable counter initialized on Line 2 to 0, will be incremented in the while loop each time the user enters another integer so that we know how many they entered in total.
• The variable int_sum initialized on Line 3 to 0, is an accumulator, that is, each time the user enters an integer we add their integer to int_sum so that by the end we will have the sum of their integers.
• On Lines 4, 7, 10, 16, 18, and 25 we use Python's ability to repeat a character using the * operator to draw a dashed line as separators for our output. This is commonly used to produce well-formatted output.
• On Lines 5, 6, 7, and 8 we print instructions for the user.
• Line 11 demonstrates the input statement to prompt the user for (in this case) an integer. Notice that the input statement includes the prompt text inside its parentheses. The user_int variable will contain what they type when they press Enter. Also, remember that anything typed by the user at an input prompt will be a string (including numbers) so we will have to cast their entries which we see on Line 13.
• Line 12 contains our while loop. Notice the syntax here: while user_int != "":. What does this mean? Again, remember that the user's entry at the input prompt is a string, so we can take advantage of this fact by using, as our boolean expression, user_int != "" which means this while loop will continue until the user presses Enter without entering a value, as indicated in our user instructions on Lines 8 & 9 in the code.
• Line 13 is our accumulation line, each time a user enters an integer we cast their entry (stored in the user_int variable) to an integer and add it to the int_sum accumulator variable. In this manner, each iteration of the loop builds a running total of their integers.
• On Line 14 we increment our counter variable. Like the sum accumulator, incrementing this counter variable provides us with a running total of the number of integers they have entered.
• Line 15 prints a new prompt on the screen asking them for their next integer. Notice that because this is inside the loop (we know this because it is indented), each time the user enters a new integer this prompt will appear again and again until the user presses Enter without typing an integer as instructed above.
• The while loop is contained on Lines 12 thru 15. Notice the indentation, it is a requirement of Python for that indentation to be used to indicate what statements are part of the loop.
• Line 17 prints a report header line, this is for user-friendliness.
• Line 19 is an example of programmatic validation. We will discuss this a lot more later, but this is a good example to introduce the idea of validating user input and data in our programs. The purpose of this particular validation, if counter > 0: ensures that the user has entered at least 1 integer. If they don't then we do not want to perform the calculations because we'll get a runtime error. Any idea why?
• The runtime error would occur if no values were entered, that is, the user pressed Entry with no value on the first prompt because computers cannot divide by zero so the average calculation on Line 22 would throw an error. So, to avoid this, we confirm at least 1 value was entered with the if statement.
• If values were entered, then Lines 20, 21, and 22 would run and print summary values for the counter, sum, and average.
• If no values were entered, the counter would still be zero (it was initialized to 0 on Line 2) therefore the else statement would run the print statement on Line 24.

As indicated above, while loops are pre-test loops that depend on a boolean expression condition to determine if the statements inside the loop should run and how many times. What if that boolean expression remains true, that is, there is no change to the boolean expression variables in the loop that causes it to ever turn false? The result is, what we call, an infinite loop. Infinite loops can occur accidentally though an error in coding or logic, or they can be intentional. In either case, if not terminated in some way, an infinite loop would repeat forever.

Consider the following code:

while True:
    print("Hello")

If we run this code, what is the result? Since the boolean expression condition of this while loop is simply True, and nothing inside the loop statements will terminate the loop, it will run forever.

Here's another example:

x = 1
while x > 0:
    print("Hello")

This is also an infinite loop. Why? Our boolean expression is valid and will run the loop as long as x is greater than zero. The problem is that we initialized x to equal 1, and there is nothing in the loop that changes the value of x, so it remains 1 which is greater than zero, so the boolean expression never turns False. This is a common mistake, where we write a while condition but inadvertently forget to include code inside the loop to finish the loop.

Python includes a break statement that terminates the execution of a loop. This is often called brute force termination because your boolean expression should handle the termination of a loop. However, the break statement is useful in some circumstances. Use of the break statement is often strongly discouraged in production code. Here's an example of its use:

counter = 1
while True:
    print(counter)
    counter += 1
    if counter > 75:
        break
print("Done")

This example is similar to our first infinite loop example above. The boolean expression is while True: so this loop will not terminate on its own based on the while condition. However, we've set a counter and increment the counter inside the loop. The if statement inside the loop includes a boolean expression that monitors the value of the counter variable. When that value is greater than 75, we use the break statement and the loop terminates.

This last example simulates what is called a counter-controlled loop, which Python provides and is called the for loop. We will cover the for loop on the next page.