# 4.7. The range Function¶

In our simple example from the last section (shown again below), we used a list of four integers to cause the iteration to happen four times. We said that we could have used any four values. In fact, we even used four colors.

```import turtle            # set up alex
wn = turtle.Screen()
alex = turtle.Turtle()

for i in [0, 1, 2, 3]:   # repeat four times
alex.forward(50)
alex.left(90)

wn.exitonclick()
```

It turns out that generating lists with a specific number of integers is a very common thing to do, especially when you want to write simple `for loop` controlled iteration. Even though you can use any four items, or any four integers for that matter, the conventional thing to do is to use a list of integers starting with 0. In fact, these lists are so popular that Python gives us special built-in `range` objects that can deliver a sequence of values to the `for` loop. When called with one parameter, the sequence provided by `range` always starts with 0. If you ask for `range(4)`, then you will get 4 values starting with 0. In other words, 0, 1, 2, and finally 3. Notice that 4 is not included since we started with 0. Likewise, `range(10)` provides 10 values, 0 through 9.

```for i in range(4):
# Executes the body with i = 0, then 1, then 2, then 3
for x in range(10):
# sets x to each of ... [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
```

Note

Computer scientists like to count from 0!

So to repeat something four times, a good Python programmer would do this:

```for i in range(4):
alex.forward(50)
alex.left(90)
```

The range function is actually a very powerful function when it comes to creating sequences of integers. It can take one, two, or three parameters. We have seen the simplest case of one parameter such as `range(4)` which creates `[0, 1, 2, 3]`. But what if we really want to have the sequence `[1, 2, 3, 4]`? We can do this by using a two parameter version of `range` where the first parameter is the starting point and the second parameter is the ending point. The evaluation of `range(1,5)` produces the desired sequence. What happened to the 5? In this case we interpret the parameters of the range function to mean range(start,beyondLast), where beyondLast means an index past the last index we want. In the 2-parameter version of range, that is the last index included + 1.

Note

Why in the world would range not just work like range(start, stop)? Think about it like this. Because computer scientists like to start counting at 0 instead of 1, `range(N)` produces a sequence of things that is N long, but the consequence of this is that the final number of the sequence is N-1. In the case of start, stop it helps to simply think that the sequence begins with start and continues as long as the number is less than stop.

Note

The range function is lazy: It produces the next element only when needed. With a regular Python 3 interpreter, printing a range does not calculate all the elements. To immediately calculate all the elements in a range, wrap the range in a list, like `list(range(4))`. Activecode is not designed to work on very long sequences, and it may allow you to be sloppy, avoiding the list function, and see the elements in the range with `print(range(4))`.

Here are two examples for you to run. Try them and then add another line below to create a sequence starting at 10 and going up to 20 (including 20).

Codelens will help us to further understand the way range works. In this case, the variable `i` will take on values produced by the `range` function.

Activity: CodeLens 4.7.3 (rangeme)

Finally, suppose we want to have a sequence of even numbers. How would we do that? Easy, we add another parameter, a step, that tells range what to count by. For even numbers we want to start at 0 and count by 2’s. So if we wanted the first 10 even numbers we would use `range(0,19,2)`. The most general form of the range is `range(start, beyondLast, step)`. You can also create a sequence of numbers that starts big and gets smaller by using a negative value for the step parameter.

Try it in codelens. Do you see why the first two statements produce the same result?

Activity: CodeLens 4.7.5 (rangeme2)