Variables

Consider the following code:

def paint_green(bit):
    while bit.front_clear():
        bit.move()
        bit.paint('green')

This tells Bit to keep moving and painting green as long as the front is clear. So Bit will paint an entire row or column green, depending on which direction it is facing.

But what if we also want to paint rows and columns red? And yellow and green and brown and blue?

We would need to write a separate function for each one! Not great!

Functions can have multiple parameters

Never fear, it turns out that functions can take multiple parameters:

def go(bit, color):
    """ Given a bit and a color, move and paint that color until blocked """
    while bit.front_clear():
        bit.move()
        bit.paint(color)

The go() function takes two parameters:

• a Bit
• a color

Inside the go() function, the variable called bit is equal to the Bit, and the variable called color is equal to whatever color you give it. You can see this in action using the file called go_color.py in the zip file above:

from byubit import Bit


def go(bit, color):
    """ Given a bit and a color, move and paint that color until blocked """
    while bit.front_clear():
        bit.move()
        bit.paint(color)


@Bit.empty_world(5, 3)
def lots_of_paint(bit):
    """ Paint colors until blocked """
    go(bit, 'red')
    bit.left()
    go(bit, 'green')
    bit.left()
    go(bit, 'blue')


if __name__ == '__main__':
    lots_of_paint(Bit.new_bit)

Bit starts in an empty 5x3 world. It does the following:

• paints a row red
• turns left
• paints a row green
• turns left
• paints a row blue

The result is this world:

Parameters become variables in a function

To see how parameters to a function work, look at this diagram:

The first time this code calls go(), it uses 'red' as the second parameter. This means that inside the go() function, there is a variable called color that is equal to the string 'red'.

The second time this code calls go(), we have this situation:

This time, the code uses 'green' as the second parameter. This means that inside the go() function, the variable called color is equal to the string 'green'.

Notice that we use the notation color → 'red' and color → 'green' in this pictures. This indicates that a variable has a name (color) and it references a value (‘red’ or ‘green’). The value of a variable can change over time.

Changing the value of a variable

You can change the value of a variable any time using this syntax:

my_color = 'red'

Here, the variable is called my_color and its value is 'red'. Using our notation, my_color → 'red'.

Then you can call functions using this variable:

my_color = 'red'
go(bit, my_color)
my_color = 'blue'
go(bit, my_color)

The first time, my_color → 'red' and so inside go(), color → 'red'.

The second time, the value of my_color changes, so now my_color → 'blue' and inside go(), color → 'blue'.

Painting with different colors

You can see this in action with the file called color_variables.py in the zip file above:

from byubit import Bit


def paint_two(bit, color):
    bit.paint(color)
    bit.move()
    bit.paint(color)


def paint_three(bit, color):
    paint_two(bit, color)
    bit.move()
    bit.paint(color)


@Bit.empty_world(5, 3)
def run(bit):
    first_color = 'red'
    second_color = 'blue'

    paint_two(bit, first_color)
    bit.move()
    paint_three(bit, second_color)

    bit.left()
    bit.move()
    bit.left()

    paint_two(bit, second_color)
    bit.move()
    paint_three(bit, first_color)


if __name__ == '__main__':
    run(Bit.new_bit)

Here we have a function called paint_two(bit, color) that takes two parameters, a bit and a color. It does this:

• paint the color
• move
• paint the color

We have another function called paint_three(bit, color) that takes the same two parameters. It does this:

• call paint_two()
• move
• paint the color

This allows it to paint three colors.

Finally, we have two variables: first_color → 'red' and second_color → 'blue'. We use these two variables when we call the functions, so that we can:

• paint two blue squares (using first_color)
• paint three red squares (using second_color)
• turn around and go to the next row up
• paint two red squares (using second_color)
• paint two blue squares (using first_color)

Run this code and see the result:

Getting the current color

Bit has a useful function called get_color() that lets you get the color of Bit’s current square so you can store it in a variable. For example:

found_color = bit.get_color()

Consider the following problem. Bit is in a world with one color:

Bit’s job is to find out what color this is and then fill in the rest of the row with that same color:

But Bit doesn’t know what color it is going to have in that first square. It might be blue:

Look a the file called fill_a_color.py to see how to do this:

from byubit import Bit


def go(bit, color):
    while bit.front_clear():
        bit.move()
        bit.paint(color)


@Bit.worlds('color1', 'color2')
def fill_a_color(bit):
    found_color = bit.get_color()
    go(bit, found_color)


if __name__ == '__main__':
    fill_a_color(Bit.new_bit)

In fill_a_color(), Bit first gets the current color and stores it in a variable called found_color. It then uses found_color when it calls go().

Run this code and use the buttons to see that it solves both worlds. In the first world, bit.get_color() returns 'red', and so found_color → 'red'. In the second world, bit.get_color() returns 'blue', and so found_color → 'blue'.