# Flow control—iteration

Objectives

• Know how to use `for` and `while` statements for repeated execution.

In this lesson, we will look more at how we can control the flow of our programs. We will investigate how we can execute statements multiple times, using the `for` and `while` commands in Python.

Once again, we will consider an example situation involving an experiment in which multiple trials are presented. This experiment is extremely simple, and only consists of the trial number being printed to the screen.

If we have five trials, we could achieve this by writing:

```print 1
print 2
print 3
print 4
print 5
```
```1
2
3
4
5
```

Obviously, this is going to get very tedious and error-prone, particularly if there are lots of trials or the code for each trial is complex. Since it is likely that both these factors will be true for any real experiment that we would run, we need to find a way to automate these repeated tasks.

## `for` loops

We can do so using a `for` loop. This construct takes a collection of data and loops over the items one at a time. For example:

```trials = range(1, 6)

for trial in trials:
print trial
```
```1
2
3
4
5
```

As you can see, this produces the same outcome as the manual way. Let’s unpack how it works.

• First, we used the `range` function to generate a list of the integers 1 through 5.

• We then define our loop:

• We start by using `for`, which is a special Python keyword.
• We then specify a variable name—as usual, this can be close to anything we like, and here we call it `trial`.
• We then give another special Python keyword, `in`, followed by our list, followed by a colon (`:`).
• This sequence can be read as “loop over the items in the list called trials, each time calling the item trial”.
• We then define what happens on each pass through the loop:

• We use indentation again to indicate nested program structure; everything that is indented ‘under’ the `for` line is executed once for every item in the `trials` list.
• On the first pass through, the variable `trial` is set to the number 1, because that is the first item in the `trials` list, and the `print` statement outputs it to the screen.
• On the second pass through, the same process occurs except the variable `trial` is now set to the number 2, the second item in the `trials` list.
• This process continues until all the items in the `trials` list have been used.

## `while` loops

The `for` loop construct is very useful, but is sometimes not ideal because we have to specify exactly how many iterations we want to perform (how many items in the list). Sometimes we don’t know how many iterations we want to run—we only know that we want to continue iterating until some desired state is reached.

We can reproduce the same functionality as our `for` loop using a `while` loop as follows:

```trial = 1

while trial < 6:

print trial

trial = trial + 1
```
```1
2
3
4
5
```

Let’s consider how this worked:

• First, we established an initial condition by creating the variable `trial` and giving it a value of `1`.
• We then indicated that we would like to define a `while` loop.
• The expression immediately following the `while` keyword establishes the conditions under which the loop should continue. As long as the expression evaluates to `True` (“while” the expression evaluates to `True`), the “body” of the loop is repeatedly executed. Here, we tell Python to continue executing the loop while the value in the variable `trial` is less than 6.
• We then include a colon (`:`) to indicate that we are ready to specify the body of the loop.
• We then indent, to indicate that we are within the body of the loop, and specify the command that we want to occur on each pass through the loop (printing the contents of the variable `trial`).
• The final, and critical, step is to increment the value in the variable `trial`. That way, the loop will terminate once the value of `trial` gets beyond 5.

Tip

A potential caution with `while` loops is that is easy to produce an “infinite loop” by having a test that will never evaluate to `False`—meaning your program would run forever!

Let’s look at another example. Say a trial involves presenting a dynamic pattern that the participant needs to make a judgement about. We don’t know precisely when they will make this judgement, because it is up to the participant. This is a good situation for using a `while` loop.

To simulate a participant in our example, we will draw a random number on each iteration of the loop. If this random number is above 0.9, we take that as akin to a participant response and we end the loop. For example:

```import random

responded = False

while not responded:

print "Looping!"

if random.random() > 0.9:
responded = True
```
```Looping!
Looping!
Looping!
Looping!
Looping!
Looping!
Looping!
Looping!
Looping!
Looping!
Looping!
Looping!
Looping!
Looping!
Looping!
Looping!
Looping!
Looping!
Looping!
Looping!
Looping!
Looping!
Looping!
Looping!
Looping!
```

Let’s work through what is happening in the above code.

• First, we imported the extra functionality available in the `random` package.
• Next, we defined a variable that is a boolean indicating whether the participant has responded yet; our initial state is that they have not responded.
• We then start our loop by using the special Python keyword `while`, followed by something that evaluates to a boolean—in this case, we are testing whether participants have not yet responded. As long as this boolean evaluates to `True`, the code that is indented beneath the `while` line will repeatedly execute.
• Because it starts out as `True` (because we set `responded` to `False`, and `not False` is `True`), we begin to execute the indented code.
• First, we print out a string just to show that we are executing this particular line of code.
• Next, we generate a random number between 0 and 1 and test if it is greater than 0.9.
• If it is, we set the variable `responded` to the value of `True`.
• We then go back up to our `while` loop definition, and evaluate the boolean test again.
• If it continues to evaluate to `True`, we go and execute the code again.
• However, if it now evaluates to `False`, then we don’t execute the code and we move on and finish the program.