To start this guide, download this zip file.
Practice with if statements
These problems will give you a chance to practice using
if statements. Use the
event stream pattern, and think carefully about when you need to use
Download the zip file above and put it in your
For this problem, Bit starts in this world:
Bit is a pipe, and the pipe has holes on each side. Bit’s job is to mark where the holes are so someone else can fix them. Bit goes down the center and follows these rules:
- mark holes on the right by painting the current square red
- mark holes on the left by painting the current square green
- otherwise paint squares blue
The ending world should look like this:
You will find starter code in
from byubit import Bit
@Bit.worlds('holes') def run(bit): # Write code here pass if __name__ == '__main__': run(Bit.new_bit)
You should use the
event stream pattern to solve this problem.
A good way to think about problems that use
if statements is to use a flow
In a flow chart, the rectangles represent a
process — something you do — and
the triangles represent a
decision — a condition for a while loop or if
The purple square represents a separate function we have to write. We can call
helper function, because it helps the main function do its job.
In this flow chart, we have separated the main function into the left side and a helper function on the right side. This helps make the event stream pattern clear. The main function moves forward, and the helper function handles the event stream.
How would you turn this flow chart into code?
One thing to spot from this flow chart is that we should have a while loop for
the decision labeled
is the front clear? because we loop back to check this
repeatedly. We should have an
if-elif-else statement for the other three
Here is one way to do this:
# Solution from byubit import Bit def change_square(bit): if bit.right_clear(): bit.paint('red') elif bit.left_clear(): bit.paint('green') else: bit.paint('blue') @Bit.worlds('holes') def run(bit): bit.paint('blue') while bit.front_clear(): bit.move() change_square(bit) if __name__ == '__main__': run(Bit.new_bit)
Run this code and use the buttons to step through it carefully to be sure you
if statements work.
In this problem, Bit starts in this world:
Bit is flying around and follows these rules:
when Bit finds a blue square, it turns left.
when Bit finds a green square, it turns right.
when Bit finds a red square, it stops.
How would you turn these rules into a flow chart?
Here is one way to do this:
The import thing to recognize here is that the main function checks whether the current square is red. This is because of the final rule listed above — when Bit finds a red square, it stops. Instead of moving while the front is clear, we move while the current square is not red.
We are again using the
event stream pattern, with a main function that moves
forward and a helper function that turns as needed.
Can you turn this into code?
Notice that the main function moves while the current square is not red. This
is a signal that you need to use
while not bit.is_red(). Here is the code:
# Solution from byubit import Bit def maybe_turn(bit): if bit.is_blue(): bit.left() elif bit.is_green(): bit.right() @Bit.worlds('fly') def run(bit): while not bit.is_red(): bit.move() maybe_turn(bit) if __name__ == '__main__': run(Bit.new_bit)
if statement uses
elif but does not need an
We could have also written the
maybe_turn() function as:
def maybe_turn(bit): if bit.is_blue(): bit.left() if bit.is_green(): bit.right()
This works because Bit can never be on a square that is both blue and green at the same time.
We could also have reversed the
bit.move() and the
def run(bit): while not bit.is_red(): maybe_turn(bit) bit.move()
The solution works whether Bit moves and then turns, or if Bit turns and then moves. This works because Bit does not start on a square that is blue or green. If it did, then you would want to check for a turn before moving.
Run the code above and use the buttons to be sure you understand how and why it works.
Try adding these bugs to the code above to see what happens:
In the main function, go forward while the front is clear.
maybe_turn()function, turn right on blue and left on green.
In each case, step through the code with
Next to observe what