Lists and Compass

Why lists?

At this point, hopefully you agree that we can do a lot of cool and different things with our programs.

In the last post, we learnt how to make code repeat certain instructions for an arbitrarily long time (Repeat this until this condition is true). What we are missing, however, is a similar thing for variables.

Consider a previous example of computing the square numbers smaller than 50:

1
2
3
4
5
6
7

x = 1

# Print x * x while it is <= 50.
while x * x <= 50:
    square = x * x
    print(f"{x}^2 = {square}")
    x = x + 1

1
2
3
4
5
6
7
8

### Output ###
>>> 1^2 = 1
>>> 2^2 = 4
>>> 3^2 = 9
>>> 4^2 = 16
>>> 5^2 = 25
>>> 6^2 = 36
>>> 7^2 = 49

The main problem we run into is: After this loop has run, how can we remember all of the square numbers we calculated? We can’t create a new variable for each, because we don’t necessarily now how many times this loop will run. That’s where the list comes into play!

Creating

A list does what it says on the tin: It is a list of other bits of data, and it starts and ends with square brackets []. Creating a list in python is super simple, you just write out the list as data:

1
2
3

my_number = 3
# This is a list, with 3 items.
my_list = [1, "two", my_number]

We can find the length of a list (how many items are in it) by writing len(my_list).

You can also add to a list, with .append(). So we can rewrite our old program to store the squares:

1
2
3
4
5
6
7
8
9
10
11
12
13

x = 1
# Create an empty list
squares = []

# Print x * x while it is <= 50.
while x * x <= 50:
    square = x * x
    # Add square to the list
    squares.append(square)
    x = x + 1

print(f"There are {len(squares)} squares <= 50")
print(squares)

1
2
3

### Output ###
>>> There are 7 squares <= 50
>>> [1, 4, 9, 16, 25, 36, 49]

Changing and Accessing

Creating a list is cool and all, but storing data is only useful if you can later modify or retrieve it. For example, in the code above, we might want to ask “What is the third square?”. To do this, we write squares[2]. squares[0] is the first element (1), squares[1] is the second element (4), and squares[2] is the third element (9). This continues until the end of the list.

squares[0],squares[1],squares[2]... are essentially just variables, you can read and change their values in the same way. Because of this, we can also change the list. Writing squares[4] = 0 will change the 5th item in the list from 25 to 0.

1
2

  my_list = [1, 2, 3]
  # ... your code goes here.

1
2
3
4
5

  my_list = [1, 2, 3, 4, 5]
  print(my_list[-3])
  print(my_list[2])
  print(my_list[-1])
  print(my_list[4])

1
2
3
4
5

  ### Output ###
  >>> 3
  >>> 3
  >>> 5
  >>> 5

Strings and Splitting / Joining

One place Python already has introduced you to something like a list is strings. Strings are like lists of characters, and you can index them too:

1
2
3

my_string = "Testing"
print(my_string[2])
print(my_string[6])

1
2
3

### Output ###
>>> s
>>> g

Even more useful, we can break a string up with the split function. split takes some character in between the brackets, and will break up the original string into a list, based on this character. If no character is given in the brackets, then any empty space will break up the string.

1
2
3
4

my_underline_string = "Beep_Boop_Blargh"
my_space_string = "Hello Testing 1234"
print(my_underline_string.split("_"))
print(my_space_string.split())

1
2
3

### Output ###
>>> ["Beep", "Boop", "Blargh"]
>>> ["Hello", "Testing", "1234"]

If you want to go back from a list of strings, to one big long string, you can use the join method:

1
2
3
4

my_split_underline_string = ["Beep", "Boop", "Blargh"]
my_split_space_string = ["Hello", "Testing", "1234"]
print("_".join(my_split_underline_string))
print(" ".join(my_split_space_string))

1
2
3

### Output ###
>>> Beep_Boop_Blargh
>>> Hello Testing 1234

a.join([x, y, z]) will print xayaz (Joining the items in the list, with a in between).

The Compass Sensor

So far we’ve just been turning left/right/up/down by remembering our current direction, and rotating accordingly. However, this is bad for a few reasons:

• In real life, we can’t get exactly straight in one direction. After a series of turns, we will slowly drift off course.
• Storing this memory of which direction we are facing gets a bit annoying.
• It is even harder to do with any general rotation, not just the four cardinal directions.

For this reason we introduce the Compass Sensor. The Compas Sensor has a pretty simple purpose - it tells us what rotation we have, relative to some starting point. We use it in a very similar way to the infrared sensor:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

import time
from ev3dev2.sensor import Sensor, INPUT_1

# Connect to the sensor
compass = Sensor(INPUT_1, driver_name="ht-nxt-compass")

# Calibrate the compass (Tell it what north is)
compass.command = "BEGIN-CAL"
compass.command = "END-CAL"

while True:
    # This ranges from 0 to 359 (Clockwise rotation from starting position).
    bearing = compass.value()
    print(f"We are at {bearing} degrees")
    time.sleep(0.5)

After calibrating, the compass should return value of 0. This means that it is facing North (or what the robot thinks is North). Then, if we rotate it counter-clockwise 90 degrees, you should find that the compass.value() returns about 90. With this, we can tell our current rotation based on when we calibrated.

1
2
3
4
5
6
7
8

  # Name, Distance, Degrees.
  my_locations = [("Hospital", 15, 250), ("Market", 24, 45)]
  # Martin wants to go to the market.
  martin_goes = "Market"
  index = 0
  while index < len(my_locations):
      if my_locations[index] == martin_goes:
          # Now we can move to that location!

List Splicing

Simple splicing

One other cool thing we can do with lists is splice them. Splicing is similar to indexing, although rather than just retrieving one item from the list, you can retrieve multiple. The code is very similar to indexing.

To get the 3rd, 4th and 5th items from a list, you can write the following:

1
2

my_list = [1, 2, 3, 4, 5, 6, 7]
print(my_list[2:5])

1
2

### Output ###
>>> [3, 4, 5]

The left number is where to start the splice (2 means 3rd item, just like indexing), and the right number is where to end the splice (5 means stop before the 6th item).

If you leave these numbers blank, then they default to the start and end of the list.

1
2
3

my_list = [1, 2, 3, 4, 5, 6, 7]
print(my_list[:3])
print(my_list[3:])

1
2
3

### Output ###
>>> [1, 2, 3]
>>> [4, 5, 6, 7]

Negatives and Jumps

Splice indicies can also be negative, so my_list[-3:-1] would get the 3rd and 2nd last elements.

Lastly, a third number can be given in a slice, to change the distance between items selected:

1
2
3
4
5

my_list = [1, 2, 3, 4, 5, 6, 7]
# Start at the start of the list. Jump 2 every time until the end.
print(my_list[::2])
# 2nd until the 7th element. Jump 3 every time.
print(my_list[1:6:3])

1
2
3

### Output ###
>>> [1, 3, 5, 7]
>>> [2, 5]

The distance given can also be negative, to reverse the order of elements! (Have a play around).

Fast Looping

Last week we covered the while loop, a bit of code that runs a variable (variable in that it varies) amount of times. And this week we covered lists, a data type whose length varies. Because of this, we often end up writing very similar bits of code to loop over the items in a list, or something similar:

1
2
3
4
5
6

my_list = [...]

counter = 0
while counter < len(my_list):
    # Do something with my_list[counter]
    counter = counter + 1

However, there’s a lot of things we can miss here, like:

• counter = counter + 1 (Or your code just runs forever)
• Creating the variable counter = 0.
• Using the correct statement counter < len(my_list)

Which all sounds simple, but in the middle of a large program you can definitely forget! Luckily Python has a few more keywords designed specifically for looping over lists and similar objects.

On lists

If we want to loop over the items in a list, we can use the following code:

1
2
3

my_list = [1, 2, 3]
for list_item in my_list:
    print(list_item)

1
2
3
4

### Output ###
>>> 1
>>> 2
>>> 3

The for loop acts like a while loop, where it repeats indented code. Instead of a condition to stop looping, you specify a variable (list_item), and a collection of items (my_list).

The for loop then repeats the indented code, once for every item in the collection, setting list_item to that particular item.

You can also do this with strings, since they can be viewed as a collection of characters!

1
2
3

my_string = "abcd"
for my_char in my_list:
    print("Next character is:", my_char)

1
2
3
4
5

### Output ###
>>> Next character is: a
>>> Next character is: b
>>> Next character is: c
>>> Next character is: d

On numbers

One bad thing about these for loops so far is that we can’t modify the lists at the same time. For example we couldn’t really translate this block of code into using a for loop:

1
2
3
4
5
6

my_list = [1, 2, 3]
counter = 0
while counter < len(my_list):
    my_list[counter] = my_list[counter] + 4
    counter = counter + 1
print(my_list)

1
2

### Output ###
>>> [5, 6, 7]

However, rather than trying to loop over the collection of items in the list, what if we could instead loop over the indexes of the list? Well you’re in luck!

1
2
3
4
5
6
7

my_list = [1, 2, 3]

for counter in range(0, len(my_list))
    print(counter)
    my_list[counter] = my_list[counter] + 4

print(my_list)

1
2
3
4
5

### Output ###
>>> 0
>>> 1
>>> 2
>>> [5, 6, 7]

You can think of range exactly like a spliced collection of numbers. You can specify a start and an end point (Where you include the start but not the end point). So range(4, 9) = [0, 1, 2, 3, ...][4:9].

1
2

for x in range(3):
    print(x)

1
2
3
4

### Output ###
>>> 0
>>> 1
>>> 2

1
2

for x in range(3, 9, 3):
    print(x)

1
2
3

### Output ###
>>> 3
>>> 6

1
2
3
4
5
6
7

  cards = [2, 9, 6, 9, ...]

  for card1_index in range(0, len(cards)):
      #                         \/ Avoid any indexes at or before the first card.
      for card2_index in range(card1_index+1, len(cards)):
          if cards[card1_index] == cards[card2_index]:
              print("There's a duplicate!")

Project

1
2
3
4
5
6
7
8
9
10

directions = [...]
new_directions = []

# Use negative jumps in range to move backwards.
for a in range(len(directions)-1, -1, -1):
    # Add the last element to new_directions, then the second last, and so on.
    # Before that make the opposite direction though.
    if directions[a] == "North":
        new_directions.append("South")
    # and so on...