# Learning Python 3 with the Linkbot/For Loops

And here is the new typing exercise for this chapter:

```onetoten = range(1, 11)
for count in onetoten:
print(count)
```

and the ever-present output:

```1
2
3
4
5
6
7
8
9
10
```

The output looks awfully familiar but the program code looks different. The first line uses the `range` function. The `range` function uses two arguments like this `range(start, finish)`. `start` is the first number that is produced. `finish` is one larger than the last number. Note that this program could have been done in a shorter way:

```for count in range(1, 11):
print(count)
```

The range function returns an iterable. This can be converted into a list with the `list` function. Here are some examples to show what happens with the `range` command:

```>>> range(1, 10)
range(1, 10)
>>> list(range(1, 10))
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(-32, -20))
[-32, -31, -30, -29, -28, -27, -26, -25, -24, -23, -22, -21]
>>> list(range(5,21))
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
>>> list(range(5))
[0, 1, 2, 3, 4]
>>> list(range(21, 5))
[]
```

The next line `for count in onetoten:` uses the `for` control structure. A `for` control structure looks like `for variable in list:`. `list` is gone through starting with the first element of the list and going to the last. As `for` goes through each element in a list it puts each into `variable`. That allows `variable` to be used in each successive time the `for` loop is run through. Here is another example (you don't have to type this) to demonstrate:

```demolist = ['life', 42, 'the universe', 6, 'and', 7, 'everything']
for item in demolist:
print("The current item is:",item)
```

The output is:

```The current item is: life
The current item is: 42
The current item is: the universe
The current item is: 6
The current item is: and
The current item is: 7
The current item is: everything
```

Notice how the `for` loop goes through and sets item to each element in the list. So, what is `for` good for? The first use is to go through all the elements of a list and do something with each of them. Here's a quick way to add up all the elements:

```list = [2, 4, 6, 8]
sum = 0
for num in list:
sum = sum + num

print("The sum is:", sum)
```

with the output simply being:

The sum is: 20

Or you could write a program to find out if there are any duplicates in a list like this program does:

```list = [4, 5, 7, 8, 9, 1, 0, 7, 10]
list.sort()
prev = None
for item in list:
if prev == item:
print("Duplicate of", prev, "found")
prev = item
```

and for good measure:

```Duplicate of 7 found
```

Okay, so how does it work? Here is a special debugging version to help you understand (you don't need to type this in):

```l = [4, 5, 7, 8, 9, 1, 0, 7, 10]
print("l = [4, 5, 7, 8, 9, 1, 0, 7, 10]", "\t\tl:", l)
l.sort()
print("l.sort()", "\t\tl:", l)
prev = l[0]
print("prev = l[0]", "\t\tprev:", prev)
del l[0]
print("del l[0]", "\t\tl:", l)
for item in l:
if prev == item:
print("Duplicate of", prev, "found")
print("if prev == item:", "\t\tprev:", prev, "\titem:", item)
prev = item
print("prev = item", "\t\tprev:", prev, "\titem:", item)
```

with the output being:

```l = [4, 5, 7, 8, 9, 1, 0, 7, 10]        l: [4, 5, 7, 8, 9, 1, 0, 7, 10]
l.sort()                l: [0, 1, 4, 5, 7, 7, 8, 9, 10]
prev = l[0]             prev: 0
del l[0]                l: [1, 4, 5, 7, 7, 8, 9, 10]
if prev == item:        prev: 0         item: 1
prev = item             prev: 1         item: 1
if prev == item:        prev: 1         item: 4
prev = item             prev: 4         item: 4
if prev == item:        prev: 4         item: 5
prev = item             prev: 5         item: 5
if prev == item:        prev: 5         item: 7
prev = item             prev: 7         item: 7
Duplicate of 7 found
if prev == item:        prev: 7         item: 7
prev = item             prev: 7         item: 7
if prev == item:        prev: 7         item: 8
prev = item             prev: 8         item: 8
if prev == item:        prev: 8         item: 9
prev = item             prev: 9         item: 9
if prev == item:        prev: 9         item: 10
prev = item             prev: 10        item: 10
```

The reason I put so many `print` statements in the code was so that you can see what is happening in each line. (By the way, if you can't figure out why a program is not working, try putting in lots of print statements in places where you want to know what is happening.) First the program starts with a boring old list. Next the program sorts the list. This is so that any duplicates get put next to each other. The program then initializes a `prev`(ious) variable. Next the first element of the list is deleted so that the first item is not incorrectly thought to be a duplicate. Next a `for` loop is gone into. Each item of the list is checked to see if it is the same as the previous. If it is a duplicate was found. The value of `prev` is then changed so that the next time the `for` loop is run through `prev` is the previous item to the current. Sure enough, the 7 is found to be a duplicate. (Notice how `\t` is used to print a tab.)

The other way to use `for` loops is to do something a certain number of times. Here is some code to print out the first 9 numbers of the Fibonacci series:

```a = 1
b = 1
for c in range(1, 10):
print(a, end=" ")
n = a + b
a = b
b = n
```

with the surprising output:

```1 1 2 3 5 8 13 21 34
```

Everything that can be done with `for` loops can also be done with `while` loops but `for` loops give an easy way to go through all the elements in a list or to do something a certain number of times.

In this example the Linkbot will play changing tones a fixed number of times while the duration remains constant. The Linkbot can also change tone and duration a fixed number of times. Here we are using a for loop running with in a fixed range of values.

setBuzzerFrequency.py

```import barobo
dongle = barobo.Dongle()
dongle.connect()