Pre-MAP Course Website | Pre-MAP GitHub | Google
There are a few basic types of control flow statements that we will learn. These are as follows:
TrueTrueLet's look at some examples. Notice that identation (whitespace preceding code) matters in Python! Blocks of text following a for, while or if statement must be indented to run properly.
if statementWhen you need a program to do something more complicated than arithmetic, you'll sometimes need the code to do something if some condition is met, otherwise it should do something else.
One basic example is checking a password. If someone submits the right password, then tell them they're welcome, else (otherwise) give them a warning to get away. Here's how we can do that in Python:
password = 'lemon drop'
if password == 'lemon drop':
# This indented code will only run if the above condition is True
print('You are welcome here.')
else:
# This indented code will only run if the above condition is False
print('Get away!')
Copy and paste this code into the cell below, and check that it works for various values of password.
In [ ]:
The above example has only two possible outcomes - either the password is correct or incorrect. Sometimes, you'll want more possible outcomes, and for those occasions you can use the elif statement, meaning "else-if". For example, let's create a program that tells a first-year student how ready they are for a course by the course number:
course_number = 192
if course_number < 200:
print("This course is going to be fun")
elif course_number < 300:
print("This course is going to be hard")
elif course_number < 400:
print("You might want to wait for this course")
else:
print("Run away!")
Copy and paste this code into the cell below and explore the possible outputs with various inputs for course_number.
In [ ]:
In [ ]:
In the cell below, create a program that checks that the user paid the correct amount for a product. You should make two variables, customer_paid for how much the customer gave you, and price for how much the produce costs. Then your program will do one of three things:
In [ ]:
Since Python is named for the comics Monty Python, in the cell below, you will write code inspired by Monty Python and the Holy Grail. Watch this short clip from the film, then read on...
Write a program which checks if the user has counted to the correct number, and give the user responses appropriate for the number submitted.
In [ ]:
while loopThe while command is the first type of loop we'll use. A loop is a snippet of code that gets run repeatedly. Let's see an example below, where we use a while loop to add 1 to number for as many times as necessary until number is greater than or equal to 10:
number = 0
while number < 10:
print(number)
number += 1
Copy and paste the code from above into the cell below. What gets printed and why?
In [ ]:
In [ ]:
It's possible to accidentally create a loop that has no end. For example, if you wrote the above loop like this,
counter = 5000
while counter < 6000:
counter -= 10
the counter will always be less than 6000, so the condition counter < 6000 will always be True, and the loop will never end. That's called an infinite loop. If you create an infinite loop, the program will keep running forever, unless you kill it. You can kill a Python cell in an iPython Notebook by pressing the Stop button in the toolbar at the top of the page.
In this example, we'll create an infinite loop that doesn't go on forever, because it terminates with a break statement.
Let's start a counter at 10, and iteratively subtract one from counter. We could make the while loop terminate when counter == 1 by writing the loop like this
counter = 10
while counter > 1:
counter -=1
print(counter)
Or, we could break out of an infinite loop:
counter = 10
# This loop is infinite on purpose:
while True:
counter -= 1
# When counter is equal to one, break out of the loop:
if counter == 1:
break
print(counter)
Copy and paste the loop with the break from above into the cell below, and check that it works.
Modify the loop so that it terminates when the counter is at negative one million (reminder: you can use e for scientific notation)
Now modify the loop so that it counts down from 10 to negative one million by twos.
In [ ]:
for loopThe for loop is trickier to learn than the other statements we've learned so far, but it's worth the trouble!
Let's say you have a list of the names, and a list of the orbital periods of the solar system planets that you want to work on. Let's print them:
planet_names = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune', 'Pluto']
# Orbital periods in units of years:
orbital_periods = [0.24, 0.62, 1.0, 1.88, 11.86, 29.46, 84.01, 164.8, 247.7]
print(planet_names, orbital_periods)
Copy and paste this into the cell below to inspect the output:
In [ ]:
Note that the lists are printed sequentially. It would be a lot easier to read this like a table, with a column of planet names, and a column of orbital periods. We could get a table-like output by printing with a for loop.
Let's start by printing each name in the planet_names list with a for loop:
for name in planet_names:
print(name)
Let's break it down. planet_names is the list that we're going to iterate over, or loop over. When you say for name in planet_names, here's what happens:
for says you're going to start a for loopname is a new variable that you're specifying, which the for loop is going to give values toin says that each name is going to come from an element of the planet_names listplanet_names is the list that you're going to pull elements fromHere's what is going to happen when the for loop is run:
for loop sets the variable name equal to the first item in planet_names (which is "Mercury")for loop sets name equal to the second item in planet_names (which is "Venus")for loop sets name equal to the third item in planet_names (which is "Earth")You could write code that gives you the same output, but it would be really redundant:
name = planet_names[0]
print(name)
name = planet_names[1]
print(name)
name = planet_names[2]
print(name)
...
In the cell below, use the for loop above as a template to create a for loop that prints the orbital period of each planet.
In [ ]:
Now we're going to use a new function called range, which is useful in for loops.
Copy and paste this example into the cell below and look at the output:
for i in range(5):
print(i)
In [ ]:
The for loop is first setting i=0, then i=1, then i=2, etc. The range function is producing a series of consecutive integers just like np.arange did. The argument 5 tells range to produce the numbers from zero to four.
Now, let's recall how indexing of lists works. If we want to see the first element of the planet_names list we would write planet_names[0], or planet_names[1] for the second element of the list. In order to print out each element of the list one at a time, we could write something like this:
i = 0
print(planet_names[i])
i = 1
print(planet_names[i])
i = 2
print(planet_names[i])
...
or we could let the for loop do it for us without repeating any code like this:
number_of_planets = len(planet_names)
for i in range(number_of_planets):
print(planet_names[i])
This loop will do the same thing as the longer code that we wrote above, but we only had to write the print statement line one time.
Note that we had to figure out the length of the planet_names list in order to figure out at which number range should end.
Copy and paste the last for loop above into the cell below, and inspect its output.
Modify the code so that now it prints each planet name one at a time, and each orbital period.
Heads up: this is the toughest coding we've done so far, and it's going to be confusing. Nobody understands for loops the first time that they see them, so don't hesitate to ask for help. Remember to talk with your neighbors, and to raise your hand if you get stuck!
In [ ]:
In [ ]:
So far, we've seen examples where we wanted to get elements out of a list, but we also use for loops to add elements to lists. Let's make a list of the number of letters in each planet name. We could do that without a for loop like this:
# Start with an empty list:
letters_per_name = []
letters_per_name.append(len(planet_names[0]))
letters_per_name.append(len(planet_names[1]))
letters_per_name.append(len(planet_names[2]))
...
In the cell below, create an empty list called letters_per_name, then using a for loop, append to it the number of letters in each planet name. Print the completed list.
In [ ]:
Now let's build on the previous example. Copy and paste the code from the previous cell into the cell below.
This time, let's only append the letters per name to the list, if the number of letters is even. Print the result to check if it worked.
Recall: if a number is even, the modulus of that number and two is zero, for example 8 % 2 == 0
In [ ]:
In [ ]:
In [ ]:
In [ ]: