Loop Structures
and Booleans
1
Objectives
To understand the concepts of definite
and indefinite loops as they are realized
in the Python for and while statements.
To understand the programming patterns
interactive loop and sentinel loop and
their implementations using a Python
while statement.
2
Objectives
To understand the programming pattern
end-of-file loop and ways of
implementing such loops in Python.
To be able to design and implement
solutions to problems involving loop
patterns including nested loop structures.
3
Objectives
To understand the basic ideas of
Boolean algebra and be able to
analyze and write Boolean
expressions involving Boolean
operators.
4
For Loops: A Quick Review
The for statement allows us to iterate
through a sequence of values.
for <var> in <sequence>:
<body>
The loop index variable var takes on
each successive value in the sequence,
and the statements in the body of the
loop are executed once for each value.
5
For Loops: A Quick Review
Suppose we want to write a program
that can compute the average of a
series of numbers entered by the user.
To make the program general, it
should work with any size set of
numbers.
We don’t need to keep track of each
number entered, we only need know
the running sum and how many
numbers have been added.
6
For Loops iteration
7
For Loops: A Quick Review
We’ve run into some of these things
before!
A series of numbers could be handled by some
sort of loop. If there are n numbers, the loop
should execute n times.
We need a running sum. This will use an
accumulator.
8
For Loops: A Quick Review
Input the count of the numbers, n
Initialize sum to 0
Loop n times
Input a number, x
Add x to sum
Output average as sum/n
9
For Loops: A Quick Review
# average1.py
# A program to average a set of numbers
# Illustrates counted loop with accumulator
def main():
n = eval(input("How many numbers do you have? "))
sum = 0.0
for i in range(n):
x = eval(input("Enter a number >> "))
sum = sum + x
print("\nThe average of the numbers is", sum / n)
Note that sum is initialized to 0.0 so that sum/n returns a float!
10
For Loops: A Quick Review
How many numbers do you have? 5
Enter a number >> 32
Enter a number >> 45
Enter a number >> 34
Enter a number >> 76
Enter a number >> 45
The average of the numbers is 46.4
11
Example Program: Future
Value
Analysis
Money deposited in a bank account
earns interest.
How much will the account be worth
10 years from now?
Inputs: principal, interest rate
Output: value of the investment in 10
years
12
Example Program: Future
Value
Specification
User enters the initial amount to
invest, the principal
User enters an annual percentage rate,
the interest
The specifications can be represented
like this …
13
Example Program: Future
Value
Program Future Value
Inputs
principal The amount of money being invested, in
dollars
apr The annual percentage rate expressed as a
decimal number.
Output The value of the investment 10 years in the
future
Relationship Value after one year is given by
principal * (1 + apr). This needs to be done 10 times.
14
Example Program: Future
Value
Design
Display an introduction
Get the amount of the principal
(principal)
Get the annual percentage rate (apr)
Repeat 10 times:
principal = principal * (1 + apr)
Output the value of principal
15
Example Program: Future
Value
Implementation
Each line translates to one line of Python (in
this case)
Print an introduction
print ("This program calculates the future")
print ("value of a 10-year investment.")
Input the amount of the principal
principal = eval(input("Enter the initial principal:
")) 16
Example Program: Future Value
Input the annual percentage rate
apr = eval(input("Enter the annual interest rate:
"))
Repeat 10 times:
for i in range(10):
Calculate principal = principal * (1 + apr)
principal = principal * (1 + apr)
Output the value of the principal at the end of
10 years
print ("The value in 10 years is:",
principal)
17
Example Program: Future
Value
# futval.py
# A program to compute the value of an investment
# carried 10 years into the future
def main():
print("This program calculates the future value of a 10-year
investment.")
principal = eval(input("Enter the initial principal: "))
apr = eval(input("Enter the annual interest rate: "))
for i in range(10):
principal = principal * (1 + apr)
print ("The value in 10 years is:", principal)
main() 18
Example Program: Future
Value
>>> main()
This program calculates the future value of a 10-year
investment.
Enter the initial principal: 100
Enter the annual interest rate: .03
The value in 10 years is: 134.391637934
>>> main()
This program calculates the future value of a 10-year
investment.
Enter the initial principal: 100
Enter the annual interest rate: .10
The value in 10 years is: 259.37424601
19
Indefinite Loops
That last program got the job done,
but you need to know ahead of time
how many numbers you’ll be dealing
with.
What we need is a way for the
computer to take care of counting how
many numbers there are.
The for loop is a definite loop,
meaning that the number of iterations
is determined when the loop starts.
20
Indefinite Loops
We can’t use a definite loop unless we
know the number of iterations ahead of
time. We can’t know how many iterations
we need until all the numbers have been
entered.
We need another tool!
The indefinite or conditional loop keeps
iterating until certain conditions are met.
21
Indefinite Loops
while <condition>:
<body>
condition is a Boolean expression,
just like in if statements. The body is
a sequence of one or more
statements.
Semantically, the body of the loop
executes repeatedly as long as the
condition remains true. When the
condition is false, the loop terminates.
22
Indefinite Loops
The condition is tested at the top of the loop.
This is known as a pre-test loop. If the condition
is initially false, the loop body will not execute
at all.
23
Indefinite Loop
Here’s an example of a while loop that counts from 0
to 10:
i = 0
while i <= 10:
print(i)
i = i + 1
The code has the same output as this for loop:
for i in range(11):
print(i)
24
Indefinite Loop
The while loop requires us to
manage the loop variable i by
initializing it to 0 before the loop
and incrementing it at the bottom
of the body.
In the for loop this is handled
automatically.
25
Indefinite Loop
The while statement is simple, but yet
powerful and dangerous – they are a
common source of program errors.
i = 0
while i <= 10:
print(i)
What happens with this code?
26
Indefinite Loop
When Python gets to this loop, i is equal
to 0, which is less than 10, so the body of
the loop is executed, printing 0. Now
control returns to the condition, and
since i is still 0, the loop repeats, etc.
This is an example of an infinite loop.
27
Indefinite Loop
What should you do if you’re caught
in an infinite loop?
First, try pressing control-c
Ifthat doesn’t work, try control-alt-
delete
Ifthat doesn’t work, push the reset
button!
28
Exercise
Write a while loop that lets the user
enter a number. The number should
be multiplied by 10, and the result
assigned to a variable named product.
The loop should iterate as long as
product is less than 100
29
Indefinite loop
Interactive loop Sentinel loop
30
Interactive Loops
One good use of the indefinite loop is
to write interactive loops. Interactive
loops allow a user to repeat certain
portions of a program on demand.
Remember how we said we needed a
way for the computer to keep track of
how many numbers had been entered?
Let’s use another accumulator, called
count.
31
Interactive Loops
At each iteration of the loop, ask the
user if there is more data to process.
We need to preset it to “yes” to go
through the loop the first time.
set moredata to “yes”
while moredata is “yes”
get the next data item
process the item
ask user if there is
moredata
32
Interactive Loops
Combining the interactive loop pattern
with accumulators for sum and count:
initialize sum to 0.0
initialize count to 0
set moredata to “yes”
while moredata is “yes”
input a number, x
add x to total
add 1 to count
ask user if there is
moredata
output total/count
33
Interactive Loops
# average2.py
# A program to average a set of numbers
# Illustrates interactive loop with two accumulators
def main():
moredata = "yes"
total = 0.0
count = 0
while moredata[0] == 'y':
x = eval(input("Enter a number >> "))
total = total + x
count = count + 1
moredata = input("Do you have more numbers (yes or no)? ")
print("\nThe average of the numbers is", total / count)
Using string indexing (moredata[0]) allows us to
accept “y”, “yes”, “yeah” to continue the loop
34
Interactive Loops
Enter a number >> 32
Do you have more numbers (yes or no)? y
Enter a number >> 45
Do you have more numbers (yes or no)? yes
Enter a number >> 34
Do you have more numbers (yes or no)? yup
Enter a number >> 76
Do you have more numbers (yes or no)? y
Enter a number >> 45
Do you have more numbers (yes or no)? nah
The average of the numbers is 46.4
35
Exercise
Write a while loop that asks the user
to enter two numbers. The numbers
should be added and the sum
displayed. The loop should ask the
user if he or she wishes to perform
the operation again. If so, the loop
should repeat, otherwise it should
terminate.
36
Indefinite loop
Interactive loop Sentinel loop
37
Sentinel Loops
A sentinel loop continues to process
data until reaching a special value
that signals the end.
This special value is called the
sentinel.
The sentinel must be
distinguishable from the data since
it is not processed as part of the
data. 38
Sentinel Loops
get the first data item
while item is not the sentinel
process the item
get the next data item
The first item is retrieved before the
loop starts. This is sometimes called
the priming read, since it gets the
process started.
If the first item is the sentinel, the
loop terminates and no data is
processed.
Otherwise, the item is processed and
the next one is read.
39
Sentinel Loops
In our averaging example, assume
we are averaging test scores.
We can assume that there will be no
score below 0, so a negative
number will be the sentinel.
40
Sentinel Loops
# average3.py
# A program to average a set of numbers
# Illustrates sentinel loop using negative input as sentinel
def main():
total = 0.0
count = 0
x = eval(input("Enter a number (negative to quit) >> "))
while x >= 0:
total = total + x
count = count + 1
x = eval(input("Enter a number (negative to quit) >> "))
print("\nThe average of the numbers is", total / count)
41
Sentinel Loops
Enter a number (negative to quit) >> 32
Enter a number (negative to quit) >> 45
Enter a number (negative to quit) >> 34
Enter a number (negative to quit) >> 76
Enter a number (negative to quit) >> 45
Enter a number (negative to quit) >> -1
The average of the numbers is 46.4
42
Sentinel Loops
This version provides the ease of use of
the interactive loop without the hassle of
typing ‘y’ all the time.
There’s still a shortcoming – using this
method we can’t average a set of positive
and negative numbers.
If we do this, our sentinel can no longer
be a number.
43
Sentinel Loops
We could input all the information
as strings.
Valid input would be converted into
numeric form. Use a character-
based sentinel.
We could use the empty string (“”)!
44
Sentinel Loops
initialize sum to 0.0
initialize count to 0
input data item as a string, xStr
while xStr is not empty
convert xStr to a number, x
add x to total
add 1 to count
input next data item as a string,
xStr
Output total / count
45
Sentinel Loops
# average4.py
# A program to average a set of numbers
# Illustrates sentinel loop using empty string as sentinel
def main():
sum = 0.0
count = 0
xStr = input("Enter a number (<Enter> to quit) >> ")
while xStr != "":
x = eval(xStr)
total = total + x
count = count + 1
xStr = input("Enter a number (<Enter> to quit) >> ")
print("\nThe average of the numbers is", total / count)
46
Sentinel Loops
Enter a number (<Enter> to quit) >> 34
Enter a number (<Enter> to quit) >> 23
Enter a number (<Enter> to quit) >> 0
Enter a number (<Enter> to quit) >> -25
Enter a number (<Enter> to quit) >> -34.4
Enter a number (<Enter> to quit) >> 22.7
Enter a number (<Enter> to quit) >>
The average of the numbers is 3.38333333333
47
File Loops
The biggest disadvantage of our
program at this point is that they are
interactive.
What happens if you make a typo on
number 43 out of 50?
A better solution for large data sets is
to read the data from a file.
48
File Loops
# average5.py
# Computes the average of numbers listed in a
file.
def main():
fileName = input("What file are the numbers
in? ")
infile = open(fileName,'r')
sum = 0.0
count = 0
for line in infile.readlines():
sum = sum + eval(line)
count = count + 1
print("\nThe average of the numbers is", sum /
count)
49
File Loops
Many languages don’t have a mechanism
for looping through a file like this. Rather,
they use a sentinel!
We could use readline in a loop to get
the next line of the file.
At the end of the file, readline returns
an empty string, “”
50
File Loops
line = infile.readline()
while line != ""
#process line
line = infile.readline()
Does this code correctly handle the case where there’s a
blank line in the file?
Yes. An empty line actually ends with the newline
character, and readline includes the newline. “\n” !=
“”
51
File Loops
# average6.py
# Computes the average of numbers listed in a file.
def main():
fileName = input("What file are the numbers in? ")
infile = open(fileName,'r')
sum = 0.0
count = 0
line = infile.readline()
while line != "":
sum = sum + eval(line)
count = count + 1
line = infile.readline()
print("\nThe average of the numbers is", sum / count)
52
Nested Loops
In the last chapter we saw how we
could nest if statements. We can
also nest loops.
A clock is a good example of
something that works like nested
loop
53
Nested loop – Clock example
for seconds in range (60):
print(seconds)
for minutes in range (60):
for seconds in range (60):
print (minutes, “:”, seconds)
for hours in range (24):
for minutes in range (60):
for seconds in range (60):
print (minutes, “:”, seconds)
54
Nested loop
Inner loop goes through all of its
iterations for every iteration of an
outer loop
Inner loops complete their iteration
faster than outer loops
Total number of iterations for
nested loop: multiply the number of
iterations of all the loops
55
Nested Loops
Designing nested loops –
Designthe outer loop without worrying
about what goes inside
Design what goes inside, ignoring the
outer loop.
Put the pieces together, preserving the
nesting.
56
Computing with Booleans
if and while both use Boolean
expressions.
Boolean expressions evaluate to True or
False.
So far we’ve used Boolean expressions to
compare two values, e.g.
(while x >= 0)
57
Boolean Operators
Sometimes our simple expressions do not
seem expressive enough.
The Boolean operators and and or are
used to combine two Boolean expressions
and produce a Boolean result.
<expr> and <expr>
<expr> or <expr>
58
Boolean Operators
The and of two expressions is true
exactly when both of the
expressions are true.
We can represent this in a truth
table.
P Q P and Q
T T T
T F F
F T F 59
F F F
Boolean Expressions
In the truth table, P and Q represent
smaller Boolean expressions.
Since each expression has two possible
values, there are four possible
combinations of values.
The last column gives the value of P and
Q.
60
Boolean Expressions
The or of two expressions is true when
either expression is true.
P Q P or Q
T T T
T F T
F T T
F F F
61
Boolean Operators
The not operator computes the opposite
of a Boolean expression.
not is a unary operator, meaning it
operates on a single expression.
P not P
T F
F T
62
Boolean Operators
We can put these operators
together to make arbitrarily
complex Boolean expressions.
The interpretation of the
expressions relies on the
precedence rules for the operators.
63
Boolean Operators
Consider a or not b and c
How should this be evaluated?
The order of precedence, from high to
low, is not, and, or.
This statement is equivalent to
(a or ((not b) and c))
Since most people don’t memorize the
the Boolean precedence rules, use
parentheses to prevent confusion.
64
Boolean Operators
To test for the co-location of two points, we
could use an and.
if p1x == p2x and p2y == p1y:
# points are the same
else:
# points are different
The entire condition will be true only when both
of the simpler conditions are true.
65
Post-Test Loop
Say we want to write a program that is
supposed to get a nonnegative number
from the user.
If the user types an incorrect input, the
program asks for another value.
This process continues until a valid value
has been entered.
This process is input validation.
66
Post-Test Loop
repeat
get a number from the user
until number is >= 0
67
Post-Test Loop
When the condition test comes after the body
of the loop it’s called a post-test loop.
A post-test loop always executes the body of
the code at least once.
Python doesn’t have a built-in statement to do
this, but we can do it with a slightly modified
while loop.
68
Post-Test Loop
We seed the loop condition so we’re guaranteed to execute the loop
once.
number = -1
while number < 0:
number = eval(input("Enter a positive number: "))
By setting number to –1, we force the loop body to execute at least
once.
69
Boolean Expressions
as Decisions
Boolean expressions can be used as
control structures themselves.
Suppose you’re writing a program that
keeps going as long as the user enters a
response that starts with ‘y’ (like our
interactive loop).
One way you could do it:
while response[0] == "y" or
response[0] == "Y":
70
Boolean Expressions
as Decisions
>>> bool(0)
False
>>> bool(1)
True
>>> bool(32)
True
>>> bool("Hello")
True
>>> bool("")
False
>>> bool([1,2,3])
True
>>> bool([])
False
71
Boolean Expressions
as Decisions
An empty sequence is interpreted as
False while any non-empty sequence is
taken to mean True.
The Boolean operators have operational
definitions that make them useful for
other purposes.
72
Boolean Expressions
as Decisions
Sometimes we write programs that
prompt for information but offer a
default value obtained by simply pressing
<Enter>
Since the string used by ans can be
treated as a Boolean, the code can be
further simplified.
73
Boolean Expressions
as Decisions
ans = input("What flavor do you
want [vanilla]: ")
if ans:
flavor = ans
else:
flavor = "vanilla"
If the user just hits <Enter>, ans will be
an empty string, which Python interprets
as false.
74
