Unit 2 - Programming Fundamentals: Conditionals and Loops

1. Boolean Expressions and Conditionals
2. while Loops
3. Project: Craps
4. for Loops
5. Nested Loops
6. Control Structures

2.0. Boolean Expressions and Conditionals

2.0.0. Overview

In this session we'll take our first look at boolean expressions, statements which evaluate to True or False and form the foundation of conditional statements (if-elif-else ) and conditional loops ( while ).

2.1. Branching Structures

A branching structure is an element in a program that allows a decision to be made, depending on some condition. In Python, the branching structure is the if statement.

2.1.0. The if statement

if <Boolean condition>:
    <statement>
    <statement>
    <statement>
<Statement that is NOT part of the suite>

Let's see what a Boolean expressions looks like.

2.1.1 Boolean expressions

print("The elections are coming up!")
age = float(input("Your age: "))
if age >= 18:
    print("Be sure to vote!")
    print("Every vote counts!")
print("It's going to be an exciting time!")

2.1.2. Boolean expressions in branching statements

Let's take a look at how boolean expressions might be used in actual statements.

user_name = input("Enter your name: ")
print("Hi,", user_name)
if user_name == "Nat":
    print("You're awesome")
print("Goodbye,", user_name)

age = float(input("Enter your age: ))
if age >= 18:
    print("You're eligible to vote!")
if age < 18:
    print("Sorry, you can't vote yet.")

2.1.3. if-else statements

There are additional forms of the if statement that often come in handy:

if <Boolean condition>:
    <statement>
    <statement>
else:
    <statement>
    <statement>
<Statement that is continuation of program>

Thus, we can correctly analyze whether or not someone is age-eligible to be president with the following code:

age = float(input("Enter your age: ))
if age < 35:
    print("Sorry!")
    print("You're not old enough to be President of the U.S.")
else:
    print("Guess what?")
    print("You are old enough to be President of the U.S.")

Only one of the two blocks of code will be executed, depending on the value of the variable age.

Let's try writing a new program.

#!/usr/bin/env python3
"""Restaurant lunch or dinner exercise
Richard White
2012-01-30
"""

def main():
    the_time = float(input("What time is it right now (enter time as hhmm in 24 hour clock): "))
    if (the_time < 1600):
        print("The restaurant is serving lunch right now.")
        print("Would you like to hear about our specials?")
    else:
        print("The restaurant is serving dinner right now.")
        print("Can I get you a drink first?")
    
    print("Your table is right this way...")
    
if __name__ == "__main__":
    main()

2.1.4. Multiple if statements

Some problems require that there be more than a single option considered. For these cases, you basically have two possible ways two write the code:

1. Organize your logical solution so that a series of if-else statements can be nested, allowing the program's logic to drill down to find the appropriate action, or
2. if the actions can all be considered simultaneously, use an if-elif-else statement.

Usually one strategy will recommend itself over the other. The next two examples show how each of the strategies can be used to solve the problem of calculating the roots of a quadratic equation.

a, b, c = float(input("Enter coefficients a, b, and c: "))
discrim = b**2 - 4 * a * c  # "**" = exponent
if (discrim < 0):
    print("There are no real roots! Sorry!")
else:
    print("You have roots. Now calculating...")
    if (discrim == 0):   # Here's our nested if
        root = -b / (2 * a)
        print("You have a double root: ",root)
    else:
        root1 = (-b + discrim ** 0.5) / (2 * a)
        root2 = (-b – discrim ** 0.5) / (2 * a)
        print("The roots are:",root1,"and",root2)
    print("Program terminating.")

a, b, c = float(input("Enter coefficients a, b, and c: "))
discrim = b**2 - 4 * a * c            # "**" = exponent
if discrim < 0:
    print("There are no real roots! Sorry!")
elif discrim == 0:                    # "elif" means "else-if"
    root = -b / (2 * a)
    print("You have a double root: ",root)
else:                                 # if first 2 options passed...
    root1 = (-b + discrim ** 0.5) / (2 * a)
    root2 = (-b – discrim ** 0.5) / (2 * a)
    print("The roots are:",root1,"and",root2)
print("Program terminating.")

Let's try a simple exercise to put some of these pieces together:

2.1.5. Additional Boolean expressions

There are three more Boolean operators that one can use to create more complex Boolean expressions.

if age >= 13 and age <= 19:
    print("You're a teenager.")
else:
    print("You're not a teenager.")

#!/usr/bin/env python3
"""
triangle_identifier.py
@author Richard White
@version 2017-09-13
"""

def main():
    a, b, c = float(input("Enter the length of the three sides of a triangle (separated by commas): "))
    if a == b and b == c:
        print("Equilateral")
    elif a == b or b == c or a == c:
        print("Isosceles")
    else:
        print("Scalene")
    
# Call the main function
if __name__ == "__main__":
    main()

2.1.6. Boolean variables

As you become more comfortable with Boolean expressions that compare values, you will want to start creating and using Boolean variables that have a value of True or False. These have the advantage of making your program easier to read.

What does that look like? Above, we were doing an analysis of somebody's age and printing out whether or not they were a teenager. We could use a boolean variable to perform that same analysis:

if age >= 13 and age <= 19:
    is_teenager = True
else:
    is_teenager = False

And then later on in the program, perhaps:

if is_teenager:
    print("Are you as annoying as all the other teenagers?")
else:
    print("I'm so relieved you're not an annoying teenager!!")

For a single boolean analysis, this might not seem like it's any advantage, but for a complex analysis, it is often helpful to reduce your comparisons to Boolean variables.

if hungry:
    if morning:
        cook_breakfast()
    elif afternoon:
        eat_lunch()
    elif dinnertime:
        have_dinner()
    else:
        eat_a_snack()

2.2. while Loops

When we need to repeat a series of instructions in program, we use a loop structure. The type of structure you choose to use will usually depend on what kind of repetition you want to provide for.

2.2.0. Overview

When we don't know in advance how many times a program should repeat something, we usually use an indefinite loop, and in Python, the most important looping structure is the while loop.

2.2.1. Indefinite Loops

The while loop is typically used when you have a loop that needs to repeat some number of times, based on a condition. "While we haven't finished adding up this list of numbers, keep adding," for example.

while <Boolean condition>:
    <statement>
    <statement>
    <statement>
<Statement that is not part of the loop>

For our first example of a while-loop, let's begin with an if statement that prints out a "Hello" message when person enters a name. If they don't enter anything, however, we won't print anything. Either way, we'll tell them the program is done when it's over.

name = input("Enter a name: ")
if name != "":
    print("Hello", name)
print("All done")

This program works fine, but we can also modify it so that it says hello to a series of people, with just a couple of changes.

Take a look at this version of the program. It will say "hello" to each person until the empty string ("") is entered, where "" is the sentinel value for the loop.

name = input("Enter a name: ")
while name != "":
    print("Hello", name)
    name = input("Enter another name: ")
print("All done!")

Here, the sentinel value that will end the loop is the empty string "". As long as name doesn't have the value "", the loop will continue to run, saying "Hello" using every name that is entered. Once no value ("") is entered, the boolean expression becomes False and the body of the loop is not executed. Instead, execution proceeds to the line below the body of the loop.

Sample output:

Enter a name: Richard
Hello Richard
Enter another name: David
Hello David
Enter a name: Amanda
Hello Amanda
Enter a name: Claudine
Hello Claudine
Enter a name: ([Enter] is pressed with no value entered)
All done!

A sentinel value can be used in lots of different applications. One common example is playing a game. The program will play a game, then ask the user if they want to play again. As long as the user doesn't enter the sentinel value of "No" (or "Quit", etc.), the game loop keeps repeating.

2.2.2 Using while loops to validate input

Your program will be more robust, and less fragile, if it attempts to validate input, making sure that the data coming in to the program is appropriate.

Not validating input makes your program easier to break, and in security applications, can be downright dangerous to your program, your user's data, and your computer.

Here are two quick examples of how you can use a while loop to validate a user's input after he/she has entered it.

# Program to validate input > 0
number = float(input("Enter a number and I'll calculate its square root: "))
while (number < 0):
    print("Error: square roots of negative numbers aren't allowed.")
    number = float(input("Please enter a positive number: "))
print("Positive number received!")
print("The square root of", number, "is", number ** 0.5)

Here's another way to do the same thing. This next version of the program uses a loop that would repeat infinitely, except for the fact that—once we get the positive number that we're looking for—we use the break statement to break out of the loop.

# Program to validate input > 0
while (True):               # this would be an infinite loop, but...
    number = float(input("Enter a number and I'll calculate its square root: "))
    if number < 0:
        print("Error: square roots of negative numbers aren't allowed.")
    else:
        break
print("Positive number received!")
print("The square root of", number, "is", number ** 0.5)

2.2.3. Counting with a while loop

A loop can also be used for is repeating something a specified number of times. Here's a while loop that counts from 0 to 9, repeating the body of the loop 10 times.

# Demonstration of counting with a while-loop
i = 0                   # initial value (inclusive)
while i < 10:           # final value (exclusive)
    print(i)
    i = i + 1           # increment counter variable i
print("All done!")

The output of this loop:

0
1
2
3
4
5
6
7
8
9
All done!

There are a couple of important things to note about this loop. We've started with the variable i at 0, and when we do that, the value 10 in the statement while i < 10 indicates the number of times that the loop will repeat. That's a pattern that we'll see often. Also, the loop does run ten times as it counts from 0 to 9. Starting our counting at 0 instead of at 1, may seem strange, but this is something that computer science people do all the time, so you'll need to get used to it: the first index (or value) that we count with is almost always 0.

If you want to have your loop print out the numbers from 1 to 10 there are a number of ways you can do that. (Try to figure out what some of them are!) But as for most of the loops we use, the variable will start at index 0.

2.2.4. Interactive loops

The interactive loop allows the user to interact with the instructions in a loop. Here's an example where we'll add a series of numbers.

# Program to add numbers
total = 0
keep_going = "Yes"
while keep_going == "Yes":
    num = float(input("Enter a number: "))
    total = total + num                 
    keep_going = input("Keep going (Yes/No)?")
print("The sum of all the numbers entered is",total)

This loop works pretty well, but one of the problems is that it's annoying for a user to have to approve every iteration.

2.2.5. More sentinel loops

One way of solving the problem of having to have a user repeatedly indicate that he/she wants to continue is by using a sentinel value. This value, when entered with the other numbers, will indicate to the loop that it should stop running.

We saw an example of this above:

# Program to say Hello to people
# using a sentinel loop
# The sentinel value is the empty string ""
name = input("Enter a name: ")
while name != "":
    print("Hello", name)
    name = input("Enter another name: ")
print("All done!")

count = 0
name = input("Enter a name: ")
while name != "":
    print("Hello", name)
    count = count + 1
    name = input("Enter another name: ")
print("All done!")
print("There were",count,"names entered!")

Here's an example of another sentinel loop: have the user enter each number as a string so that we can use a sentinel value of "". If we're going to be using the values entered as numbers, we'll need to convert them so that we can do math with them.

# Program to find the average of numbers
# using a sentinel loop
total = 0
count = 0
num = input("Enter a number, <Enter> quits: ")  
while (num != ""):
    total = total + float(num)   # float function converts
                            # a string to a number
    count = count + 1                 
    num = input("Enter a number, <Enter> quits: ")
print("You entered",count,"numbers")
print("which have a mean of",total / count)

This is the best version yet of this program.

2.2.6. Activity: number_guessing_game.py

If you're working on this problem on your own, you might want to get some advice on how to go about developing your program here.

Show/hide development steps

2.2.7. Programming Project - coin_flipper.py

For our first larger project, we're going to need a little outside help in writing the program. We're also going to introduce the format for the larger projects, which should give you the support you need to complete these assignments as required. This project is not actually much larger than the programs that we've been writing, so that makes it ideal for helping to ramp up your code-writing abilities.

2.2.7.0. coin_flipper.py

Take a moment to get the coin_flipper assignment. As much as you might consider it convenient to just work off an electronic copy on the computer, go ahead and print it on paper. It's almost always a good idea to be able to draw on the paper copy, highlight certain key ideas or components, maybe even sketch a quick flowchart or pseudocode of your solution to the program. These are things that are done more quickly and easily with a pen/pencil on paper, rather than on a keyboard. Save the keyboard for actual coding.

Got the printout? Good. Take a look at the assignment and get started.

We'll pick up where we left off here once you've completed the coinflipper assignment.

2.2.8. Code Review

You can quickly improve both your coding and your debugging skills by examining programs that other people have written.

Be sure you take a few moments to go over other people's programs, see what techniques they've used that you hadn't though of, or see how their programs might be improved.

You'll quickly come to realize how important good comments are in a program, as well as using "self-commenting" variables that help one to understand how a program works.

2.3. Project: Craps

2.3.0. Overview

We are just about at a point where our projects are too big to fit into a single "program," and that's going to require a slight modification to our thinking about our programs. Before we jump into that, though, let's make a program that will allow the user to play craps on the computer.

2.3.1. Craps Assignment

Print out the Craps assignment. As before, draw on your printout, highlight important details and make a sketch, a flowchart, and/or pseudocode of your program.

Creating a good flowchart of your program is especially useful in determining how you will organize your code in terms of both loop structures and branching structures. It's all too easy to jump into coding before you have a real sense of how you're going to systematically solve your problem. So stop... take a moment to draw up a flowchart.

Compare your flowchart with mine. They don't have to look exactly the same, but they shouldn't be too far off from each other.

You might consider looking at some advice on YouTube: part 1 and part 2.

You might also consult this pseudocode.

Once you think you have a good idea of what you want to do, open up a text editor and get coding!

2.3.2. Different structures for programs

Which of these structures most closely matches what you're writing for your program?

What are the advantages and disadvantages of each of these possible structures?

2.4. for Loops

2.4.0. Overview

Computers are good at calculating, and computers are good at repeating things very quickly.

The control structure that allows us to tell a computer how to repeat instructions is called a loop.

2.4.1. The for Loop

In programming, sometimes you'll know exactly how many times a loop is supposed to repeat before it's finished. For a loop that counts from 0 to 9 (a total of 10 times), we could use a while loop:

# Demonstration of counting with a while-loop
i = 0
while i < 10:
    print(i)
    i = i + 1       # increment counter variable i
print("All done!")

This process of counting a specified number of times is so common in computer science that Python provides for a specialized definite loop called the for loop.

# Counting values
for i in range(<initial_value (optional)>, <max_value>, <increment (optional)>):
    <statement>
    <statement>
    <statement>
<Statement that is not part of the loop>

for i in range(10):
    print(i)        # prints the values 0-9           
print("All done!")

for i in range(2, 14, 2):
    print(i)        # prints the even values 2 - 12           
print("All done!")

for i in range(10, 0, -1):
    print(i)        # prints the values 10, 9, 8, 7, 6, 5, 4, 3, 2, 1           
print("All done!")

If someone were to ask you to write a program that called helloworldmultiples.py to print "Hello, world!" five times, you might write something like this:

# print "Hello, world!" five times
def main():
    print("Hello, world!")
    print("Hello, world!")
    print("Hello, world!")
    print("Hello, world!")
    print("Hello, world!")

# Call the main function
if __name__ == "__main__":
    main()

Being able to write a program to do something a fixed number of times is nice, but we don't want to have to rewrite the program every time the number changes. What if we wanted to have "Hello, world!" print a different number of times, depending on what the user wants?

def main():
    num = int(input("How many times do you want to be greeted? "))
    for i in range(num):
        print("Hello, world!")
    print("...and goodbye!")

# for-loop example
def main():
    print "Here's a loop example"
    for i in range(10):
        print("Hello, world!")
        # this next line is indented, so it's part of the loop!
        print("Goodbye.")

if __name__ == "__main__":
    main()

Did it work? If not, you'll have to debug the program to get it running.

Note that the body of the loop—the part that's going to be repeated over and over—gets indented 4 spaces as a code block. Any statement that is indented, and thus in the code block, will be repeated as part of the loop. When you don't want the next statement to be part of the body of the loop, you stop indenting. That next statement, then, is where execution of the program will begin after the loop has finished running.

# for-loop example
def main():
    print("Here's a loop example")
    for i in range(10):
        print("Hello, world!")
        # line below indented, but not enough to be part of the loop
    print("Goodbye.")

if __name__ == "__main__":
    main()

What do you think the variable i was doing while the program ran through this loop?

# for-loop example
def main():
    print("Here's a loop example")
    for i in range(10):
        print(i, end = '')      # Try this statement and see how it affects output!
        print("Hello, world!")
    print("And that's all there is.")

if __name__ == "__main__":
    main()

In this program there were two code "blocks": the main function indented 4 spaces, and the "body" of the for loop which is indented 8 spaces.

This program uses a variable i to store a value that changes as the program runs. First the value 0 is stored in i during the first iteration of the loop, and the code block beneath is executed with the value 0 used anytime i is mentioned.

At the end of the code block, execution returns to the top of the code block, but now with i having a value of 1. The variable i gets successive values stored in it as the loop repeats over and over, ten times, with i running from 0 to 9. After that, the loop stops, and execution continues on to the next line below the loop.

2.4.2. Collection-based for loops

A loop can also go through a series of values specified in a tuple or list (we'll talk about these soon):

# Going through a tuple
for i in (2, 3, 5, 7, 11):
    print(i, "is a prime!")
print("...and there are more!")

# Going through a list
for name in ["Alex","Julian","Baptiste","Richard"]:
    print(name, "is on a road trip!")
print("and it lasted all summer long.")

Given this, let's re-examine our definition of a for-loop.

for <variable> in <sequence>:
    <body>  # Notice that the body of the loop is indented 4 spaces, 
            # as all suites should be.

Use the explanation of the for loop syntax in the green box above to analyze each of the following loops.

>>> for i in range(10):
...     print(i+1)

>>> for i in range(0,20,3):
...     print(i)

>>> for j in range(10,0,-1):
...     print(j)

>>> for j in (10,0,-1):
...     print(j)

>>> for i in ("Hello, world!"):
...     print(i)

>>> for n in ("Anne","Bob","Coraline"):
...     print(n)

Well, let's try writing a small program to practice using a simple function.

"""
99 Bottles of beer on the Wall, by Richard White                             

This program prints out all the lyrics to the song 
using a function called from within a loop.

Future improvements include:
* When only one bottle, don't say 'bottles.'
* At end, instead of 0, say 'No more...'
@author Richard White
@version 2014-09-21
"""

def print_lyrics(num):
    print(num,"bottles of beer on the wall,")
    print(num,"bottles of beer.")
    print("Take one down and pass it around.")
    print(num - 1,"bottles of beer on the wall.")
    print()

def main():
    for i in range(99,0,-1):
        print_lyrics(i)

if __name__ == "__main__":
    main()

2.5. Nested loops

There are some problems or applications that require using a loop inside another loop.

Consider a bank, for example, and this pseudocode that identifies how much money its clients have deposited there:

total_money = 0
for each client at the bank:
    for each account for that client:
        total_money = total_money + money_in_this_account
    print("Finished with client")
print("Finished with accounting")
print(total_money)

Or, an analysis of the pixels in a photo (which we'll do very soon):

for each row in the photograph:
    for each column in this row:
        # do something with the pixel at location row, col

2.5.1. Random Walkers

A random walker moves randomly through some space: along a one-dimensional number line, around a 2-dimensional grid, or through 3-dimensional space.

We can easily track a random walker by placing it at the center, choosing a random direction, and then changing the walker's x and/or y coordinates. And keep on doing that until the walker returns to its starting position, if it ever does.

y = 10
x = 20    # initial walker position
print(x, y)

direction = random.randrange(4)
if direction == 0:
    x += 1      # left
elif direction == 1:
    y += 1      # down
elif direction == 2:
    x -= 1      # right
else:
    y -= 1      # up
print(x, y)

import os
import random
import time

def main():
    WIDTH = 80
    HEIGHT = 20
    x = WIDTH // 2
    y = HEIGHT // 2
    print("{0:5d} {1:5d}".format(x, y))
    while True:
        os.system("clear")      # Clears the terminal screen
        direction = random.randrange(4)
        if direction == 0:
            x += 1
        elif direction == 1:
            y += 1
        elif direction == 2:
            x -= 1
        else:
            y -= 1
        print("{0:5d} {1:5d}".format(x, y))
        time.sleep(0.05)

if __name__ == "__main__":
    main()

2.5.2. Watching the Random Walker

Although we can track the walker's coordinates by simply printing them out in a program, it's probably more fun to be able to actually watch the walker moving around on the screen.

Let's use nested loops to print out a walker, represented by an @, on the screen.

for row in range(HEIGHT):
                for col in range(WIDTH):
                    if col == x and row == y:
                        print("@",end='')       // the walker
                    elif col == WIDTH // 2 and row == HEIGHT // 2:
                        print("+",end='')       // the middle of the screen
                    else:
                        print(".",end='')       // a blank space
                print()        # go down to the next row
            print("x=",x,"y=",y)

2.6. Control Structures

2.6.0 Overview

In this session we'll take take a large-scale overview of the control structures that can be used to manage the execution of instructions in your programs. We'll also begin your first project in this course, coinflipper.

2.6.1. Control Structures - Putting the pieces together

At this point, we've just gotten to where we're starting to have some familiarity with the two main strategies that a programmer uses in describing a programs operation.

• Loop structures allow us to make a program repeat certain sections of code
• Branching structures allow us to make the program execute different sections of code, depending on whether some condition is True or False

At this point, you might be surprised to learn that you now know just about everything about controlling execution in a program. Programs are made of sections of code that are controlled by loops and branches, combined in various ways that are determined by you, the programmer.

When looking at a computer program, or when thinking about writing a computer program, it may help you to think of the program as consisting of little chunks of code, all connected by looping and branching statements, kind of like these Lego blocks.

By carefully arranging the blocks of code, and creating the statement that need to be written by you for each block of code, we develop programs of increasing power and complexity.

A nested loop:

And when things get really crazy:

It's nice to know that we've got some of the basic building blocks down, though.