Unit 2 - Programming Fundamentals: Conditionals and Loops

1. Boolean Expressions and Conditionals
2. while Loops
3. Project: Craps
4. for Loops
5. 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

Let's see what a Boolean expressions looks like.

2.1.1 Boolean expressions

2.1.2. Boolean expressions in branching statements

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

2.1.3. if-else statements

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

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

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.

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.

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.

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:

And then later on in the program, perhaps:

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.

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.

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.

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.

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:

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.

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.

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.

The output of this loop:

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.

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:

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.

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 - coinflipper.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. coinflipper.py

Take a moment to get the coinflipper 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:

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.

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:

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?

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.

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

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):

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

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

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

2.4.3. 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:

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

2.4.4. 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.

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(20):
    for col in range(80):
        if col == x and row == y:
            print("@",end='')
        elif col = 40 and row = 10:
            print("+",end='')
        else:
            print(".",end='')
    print()        # go down to the next row
print("x=",x,"y=",y)

2.4.5. Removing Magic Numbers

The numbers 20 and 80 in the code above are "magic numbers": they represent the width and height of the grid, but it may not be immediately obvious to a human reading our program. Likewise, the 40 and the 10 represent the middle of the screen, but that's not immediately evident unless you already understand the program. And what happens if we change the width of the screen to 90? Are you going to go looking through your code to find every place where you might have referred to the width of the screen, and change all those to new magic numbers?

There's a better way. Let's represent those values as constants, variables that are customarily written in all capital letters (meaning they shouldn't change as the program is running).

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

Much better!

2.5. Control Structures

2.5.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.5.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.

There's still a lot to learn, of course. We need to examine how different types of data are stored ("data structures"), how to logically organize our programs ("functions" and "classes"), and additional ways of getting input, and delivering output.

Now try this one. It's going to use branching and looping in the same program.