Lecture 5 Loop Structures

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
 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
 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
 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
# 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
How many numbers do you have? 5

Enter a number >> 32
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
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
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
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
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)

 Output the value of the principal at the end of

10 years
print ("The value in 10 years is:",
principal)
17
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):
print ("The value in 10 years is:", principal)
main() 18
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
# 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

Do you have more numbers (yes or no)? y
Do you have more numbers (yes or no)? yes
Do you have more numbers (yes or no)? yup
Do you have more numbers (yes or no)? y
Do you have more numbers (yes or no)? nah
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
# 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) >> "))
41
Sentinel Loops
Enter a number (negative to quit) >> 32

Enter a number (negative to quit) >> -1
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
# 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) >> ")
46
Sentinel Loops
Enter a number (<Enter> to quit) >> 34

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) >>
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
while line != "":
sum = sum + eval(line)
count = count + 1
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):

print (minutes, “:”, seconds)
for hours in range (24):

for minutes 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

Lecture 5 Loop Structures

Uploaded by

Copyright:

Available Formats

Lecture 5 Loop Structures

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Lecture 5 Loop Structures

Uploaded by

Copyright:

Available Formats

Loop Structures

 To understand the concepts of definite

 To understand the programming pattern

 To understand the basic ideas of

 The for statement allows us to iterate

 Suppose we want to write a program

 We’ve run into some of these things

 Input the count of the numbers, n

How many numbers do you have? 5

The average of the numbers is 46.4

 Each line translates to one line of Python (in

 Input the amount of the principal

 Calculate principal = principal * (1 + apr)

 Output the value of the principal at the end of

principal = eval(input("Enter the initial principal: "))

print ("The value in 10 years is:", principal)

 That last program got the job done,

 We can’t use a definite loop unless we

 The condition is tested at the top of the loop.

 Here’s an example of a while loop that counts from 0

 The while loop requires us to

 The while statement is simple, but yet

 When Python gets to this loop, i is equal

 What should you do if you’re caught

Write a while loop that lets the user

Interactive loop Sentinel loop

 One good use of the indefinite loop is

 At each iteration of the loop, ask the

 Combining the interactive loop pattern

 Using string indexing (moredata[0]) allows us to

Enter a number >> 32

The average of the numbers is 46.4

Write a while loop that asks the user

Interactive loop Sentinel loop

 A sentinel loop continues to process

 get the first data item

 In our averaging example, assume

Enter a number (negative to quit) >> 32

The average of the numbers is 46.4

 This version provides the ease of use of

 We could input all the information

initialize sum to 0.0

Enter a number (<Enter> to quit) >> 34

The average of the numbers is 3.38333333333

 The biggest disadvantage of our

 Many languages don’t have a mechanism

 In the last chapter we saw how we

for seconds in range (60):

for minutes in range (60):

for hours in range (24):

 Inner loop goes through all of its

 Designing nested loops –

 if and while both use Boolean

 Sometimes our simple expressions do not

 The and of two expressions is true

 In the truth table, P and Q represent

 The or of two expressions is true when

 The not operator computes the opposite

 We can put these operators