# For loops

## Contents

# For loops#

Without us telling it otherwise, Python will execute code within a cell from top to bottom, with each line being run once. However, most of the important tasks that computers are used for involve repeating steps a large number of times. A computer’s ability to repeat steps quickly is one of the main things that make them so useful. We can have Python repeat lines by simply copy and pasting them:

```
from mobilechelonian import Turtle
tina = Turtle()
# make tina go a bit faster for convenience
tina.speed(5)
# draw a square by repeatedly moving forward then turning left 90 degrees
tina.forward(60)
tina.left(90)
tina.forward(60)
tina.left(90)
tina.forward(60)
tina.left(90)
tina.forward(60)
tina.left(90)
```

Doing this has many problems; for example, it is prone to mistakes, difficult to read, and difficult to modify (imagine we realised we wanted a hexagon instead). A `for`

loop makes the code much tidier:

```
raph = Turtle()
# make tina go a bit faster for convenience
raph.speed(5)
# To repeat something 4 times, we use the following syntax
for i in range(4):
# these indented lines will be repeated 4 times
raph.forward(60)
raph.left(90)
# To create any other regular polygon, you would only need to change two numbers
```

Let’s break down the code above. When we want Python to repeat a process a certain *number* of times, or once for each object in some sequence, we typically use a `for`

loop. The alternative is to loop until some *condition* is satisfied, which we will see in a later notebook on `while`

loops. The `for`

loop has the basic syntax

```
for x in some_sequence:
indented body statements to be repeated, possibly making use of x
next thing to do, not repeated
```

In the example above, the `some_sequence`

is `range(4)`

, which represents the sequence `0, 1, 2, 3`

.
In that example, we didn’t really care about what the sequence was, only that it had four elements in it so that the code would be repeated four times (note that the variable `i`

was never used).

Here’s an example where we actually use the sequence in the `for`

loop:

```
for i in range(4):
print(f"i is {i}")
print(f"i squared is {i**2}")
# any following unindented lines will not be repeated
print(f"now the loop is done, and the final value of i is {i}")
```

```
i is 0
i squared is 0
i is 1
i squared is 1
i is 2
i squared is 4
i is 3
i squared is 9
now the loop is done, and the final value of i is 3
```

You can use any variables in your `for`

loop; the only requirement is that `some_sequence`

makes sense to “loop over”. The technical name for this is that `some_sequence`

is * iterable*, and it includes things like

`lists`

, `sets`

, `tuples`

, and `ranges`

, and most objects which “contain” other objects.The * body* statements are repeated once for each value in the sequence. Like regular code, they are executed from top to bottom within a

`for`

loop. It is important to remember that the body statements are all executed in sequence for each value of `x`

, rather than executing the first statement for all `x`

, and then the second statement for all `x`

, and so on. You can see this behaviour in the examples above.## Computing sums and pseudocode#

A common example of where you might use a `for`

-loop is to sum up some values. For example, let’s try to compute the sum

\[ S(n) = \sum_{i = 1}^{n} i^{10}, \]

where \(n\) is fixed. When we are trying to write code to solve a problem, it is often the best strategy to first understand how we would systematically do the computation by hand. To compute \(S(n)\), the simplest method is to keep a running total, starting with zero and adding \(i^{10}\) to the total for \(i = 1, \ldots, n\). We might write this down in the following way:

We have some fixed \(n \in \mathbb{N}\)

Start with the total being 0

For \(i = 1, 2, \ldots, n\):

Add \(i^{10}\) to the total

Report the total as the answer

We call this sort of description of how to systematically solve a problem * pseudocode*. Pseudocode is not code and there is no specific standard which you must follow when writing it, but it should be possible to turn pseudocode directly into code. For example, the pseudocode above translates directly into Python like so:

```
# fix a value of n
n = 10
# start with the total being 0
total = 0
# loop through i = 0, 1, ..., n
for i in range(n + 1):
# add i**10 to the total
total = total + i**10
# report the total as the answer
total
```

```
14914341925
```

## Ranges#

In the example above, we used the command `range(4)`

to create the sequence `0, 1, 2, 3`

. Ranges are a very common way of making sequences of integers. You can see the numbers in a `range`

by using the `list`

command:

```
list(range(4))
```

```
[0, 1, 2, 3]
```

By default, a `range`

starts at `0`

and stops * before* reaching the stop value. You can change where the range starts by providing a

`start`

value as well:```
list(range(4, 10))
```

```
[4, 5, 6, 7, 8, 9]
```

Sometimes we don’t want the integers to increase by `1`

each time. We can change this by giving a `step`

argument. For example, to produce the odd numbers between 1 and 21 (inclusive), we could start at 1 and step by 2 each time:

```
list(range(1, 22, 2))
```

```
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21]
```

The `stop`

value doesn’t have to be precisely 1 more than the final value; it just has to be *less than or equal to* than the next value that the step would produce. In the previous example, using `23`

as the stop value would produce the same result.

```
list(range(1, 23, 2))
```

```
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21]
```

We can also go backwards by giving a negative step value. Note that in this case, the final element of the `range`

will be *greater* than the `stop`

value.

```
list(range(23, 11, -2))
```

```
[23, 21, 19, 17, 15, 13]
```

## Looping over lists#

It is very common to loop over a `range`

, but you can also loop over other things. We’ll see more on `lists`

later, but for now here is an example where we iterate over a `list`

of strings:

```
fruits = ["apple", "durian", "mangosteen", "pear"]
for fruit in fruits:
print(f"'{fruit}' has {len(fruit)} letters")
```

```
'apple' has 5 letters
'durian' has 6 letters
'mangosteen' has 10 letters
'pear' has 4 letters
```