Dictionaries and Functions

At this point, you’ve covered all of the sensors you can use in the simulator (and all of the sensors generally used in soccer and rescue competitions). Additionally, you have all the programming tools you need to write whatever program you desire. However, if you only use these sensors in their most basic functionality and only use the programming tools we’ve shown so far, you’d be a very messy and limited programmer, and you wouldn’t be getting the most out of your sensors.

On this page, we’ll start fixing both of these problems. You’ll learn how to fully utilise the colour sensor and some more programming tools to help with that.

Dictionaries

On the last page, with lists, remember that we needed to search through the list to find a particular item in some puzzles. For example, in the Locations puzzle:

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

my_locations = [
    # Name, Distance, Degrees
    ["Hospital", 30, 135],
    ["Hotel", 42, 84],
    ["Restaurant", 25, 285],
]

# I want to find the distance and degrees of the hotel.
# But I don't always know the Hotel is at index 1.
# So let's search for it.
for location in my_locations:
    if location[0] == "Hotel":
        print("Distance is", location[1], "and bearing is", location[2])
    else:
        print(location[0], "is not Hotel!")

1
2
3
4

### Output ###
>>> Hospital is not Hotel!
>>> Distance is 42 and bearing is 84
>>> Restaurant is not Hotel!

This is our first indicator that lists aren’t the only ways we should be storing collections of items. We need a different collection that allows us to (just like variables) give names to data, and retrieve data based on that name (So we can store data for Hotel and retrieve data for Hotel).

Once again, Python saves the day! In comes the dictionary:

1
2
3
4
5
6
7
8
9

my_locations = {
  "Hospital": [30, 135],
  "Hotel": [42, 84],
}

my_locations["Restaurant"] = [25, 285]

print(my_locations["Hotel"])
print("Distance is", my_locations["Hotel"][0], "and bearing is", my_locations["Hotel"][1])

1
2
3

### Output ###
>>> [42, 84]
>>> Distance is 42 and bearing is 84

Dictionaries are written with curly {} brackets rather than square [] ones. Like a real dictionary, you can look up a word to find its meaning. In Python terms, you can supply a key to a dictionary to find the linked item. So in a real-life dictionary, if you looked up the word Hotel, you would find the definition of Hotel is [42, 84].

The only extra thing to note is that : separates the ‘word’ from its definition (Look at the first few lines of code above). As you can see, it keeps a lot of the style of lists (accessing and changing elements with indexing using [word]).

Accurate Colour Sensing

So far, the most we’ve done with colour sensors is just to distinguish red, green and blue, which the colour sensor already does for us, for the most part. What if there are other colours we need our robot to figure out?

For now, let’s just think about introducing one more colour, yellow. Depending on how you’ve written your current colour sensing code, your robot might think yellow is red, green, or none of the three colours (but hopefully not blue!). This is because, using that Red, Green, Blue composition that the colour sensor uses, yellow is 255 for red, 255 for green, and 0 for blue (around about, obviously pure yellow in real life is hard to come by, and the colour sensors will be slightly off).

So how can we add some extra code to achieve this?

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

r, g, b = color_sensor.rgb

# Yellow check - rather lenient but still shouldn't mispick red or green.
if r > 150 and g > 150 and b < 50:
    print("Yellow!")
elif r > g + b:
    print("Red!")
elif g > r + b:
    print("Green!")
elif b > r + g:
    print("Blue!")
else:
    print("I have no idea!")

One possible solution for sensing yellow is the code in the note above, have a quick read and understand what it does.

So for yellow, we have code that checks that the red and green components are large and the blue component is small. For red, we have code that checks that the red component is large and the green and blue components are small.

In general, we can try doing a similar thing for lots of colours: The colour we are looking at is similar to some specific colour (like red, green, blue, yellow) if the r, g, b components are similar:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

r, g, b = color_sensor.rgb

# abs is a neat function that makes a number positive (-3 becomes 3, etc.)

# What is the difference from 255, 255, 0?
yellow_difference = abs(r - 255) + abs(g - 255) + abs(b - 0)
# What is the difference from 255, 0, 0?
red_difference = abs(r - 255) + abs(g - 0) + abs(b - 0)
# What is the difference from 0, 255, 0?
green_difference = abs(r - 0) + abs(g - 255) + abs(b - 0)
# What is the difference from 0, 0, 255?
blue_difference = abs(r - 0) + abs(g - 0) + abs(b - 255)

# min is another neat function, that returns the minimum of a collection of items.
min_difference = min(yellow_difference, red_difference, green_difference, blue_difference)
if yellow_difference == min_difference:
    print("Yellow!")
elif red_difference == min_difference:
    print("Red!")
elif green_difference == min_difference:
    print("Green!")
elif blue_difference == min_difference:
    print("Blue!")

Looping over dictionaries

So, we might write a similar version of our code above to store many different colours in a dictionary and then decide which of these colours is closest to what the colour sensor sees.

But to do this, we need some way to execute the code for every entry in the dictionary!

Luckily, since a dictionary is a collection of items, we can use a for loop:

1
2
3
4
5
6
7
8

my_colours = {
    "Red": [255, 0, 0],
    "Green": [0, 255, 0],
    "Blue": [0, 0, 255],
}

for key in my_colours:
    print(key, "has rgb", my_colours[key])

1
2
3
4

### Output ###
>>> Red has rgb [255, 0, 0]
>>> Green has rgb [0, 255, 0]
>>> Blue has rgb [0, 0, 255]

1
2
3
4

colours = {
    "Aqua": [20, 10, 255],
    "White": [255, 255, 255]
}

Functions

What are they?

So far in our programming, we’ve seen many different tools that used the () to get something done. Examples you’ve seen before include print, input, on_for_seconds, and many others. We’ve given them many different names throughout these pages (tools, things, methods, functions). And you might have been wondering how you can make your own.

These things are called functions, and they let you package little snippets of Python into their own self-contained bits that you can reuse. For example, let’s revisit how we calculated the colour differences before:

1
2
3
4
5
6
7
8
9
10

r, g, b = color_sensor.rgb

# What is the difference from 255, 255, 0?
yellow_difference = abs(r - 255) + abs(g - 255) + abs(b - 0)
# What is the difference from 255, 0, 0?
red_difference = abs(r - 255) + abs(g - 0) + abs(b - 0)
# What is the difference from 0, 255, 0?
green_difference = abs(r - 0) + abs(g - 255) + abs(b - 0)
# What is the difference from 0, 0, 255?
blue_difference = abs(r - 0) + abs(g - 0) + abs(b - 255)

Notice how a lot of the code is very similar, it is just that the constant 0 and 255 that are changing. Rather than having all of this repeated and hard to read code, we can use functions!

1
2
3
4
5
6
7
8
9

def colour_difference(colour1, colour2):
    return abs(colour1[0] - colour2[0]) + abs(colour1[1] - colour2[1]) + abs(colour1[2] - colour2[2])

r, g, b = color_sensor.rgb

yellow_difference = colour_difference([r, g, b], [255, 255, 0])
red_difference = colour_difference([r, g, b], [255, 0, 0])
green_difference = colour_difference([r, g, b], [0, 255, 0])
blue_difference = colour_difference([r, g, b], [0, 0, 255])

A function always starts with the def keyword, followed by the name of the function (colour_difference). After that, you’ve got round () brackets, which contain arguments of a function. arguments are like variables that you can change before running the function (So colour1 gets set to [r, g, b] and colour2 gets set to [255, 255, 0] for yellow_difference).

Then, indented just like we’ve seen before is the code the function contains. Now, whenever we write this function name, running the function is the same as running the code inside.

The last thing a function does is return. Whatever is returned from a function then becomes the value wherever the function is written, so yellow_difference becomes abs(colour1[0] - colour2[0]) + abs(colour1[1] - colour2[1]) + abs(colour1[2] - colour2[2]), where colour1=[r, g, b] and colour2=[255, 255, 0].

But why?

Functions at first might seem a bit useless, but as your programs grow longer and longer, you’ll grow to love them. They allow you to separate little bits of your program into tidy packages that can then be used all over your robot.

Additionally, it makes you give a name to a portion of the code, making it much easier to understand.

The type of function seen on the motors, like my_motor.on_for_seconds, is slightly different and will be discussed in some of the gauntlet pages.

Project time