Introduction to Bit
For the first part of the course we will be using Bit, a character that you will move around a world. Bit is depicted as a triangle:
and his world is a grid of squares:
Think of Bit as a robot that you control by writing and running code.
Basic things Bit can do
Some of the things Bit can do are:
move— one square at a time
left— turn left
right— turn right
paint— change the color of a square
To illustrate how Bit works, here is a short Bit program:
from byubit import Bit @Bit.empty_world(5, 3) def move_around(bit): bit.move() bit.move() bit.paint("red") bit.left() bit.move() bit.paint("green") bit.right() bit.move() bit.paint("blue") if __name__ == '__main__': move_around(Bit.new_bit)
We will explain all this code shortly, but for now, focus on these lines:
bit.move()— moves bit one square to the right
bit.left()— turns bit to the left
bit.right()— turns bit to the right
bit.paint("red")— paints the current square red
Each of these commands is a function that you are calling. Every time you
call a function you use parentheses:
(). Inside the parentheses are the
arguments or parameters for the function.
right() functions do not take any arguments. The
paint() function takes one argument — the name of a color.
Bit understands three colors:
These must be in double quotes or single quotes.
We can run this program by clicking the green triangle next to the line of code
that starts with
We will explain this below. Here is what it looks like in PyCharm:
Here is what you should see:
This shows that bit moved through the world and painted some squares.
Use these buttons to “replay” what Bit did:
First— moves back to the first line of code
Prev— moves back one line of code
Next— moves forward one line of code
Last— moves to the last line of code
As you move, the top part of the world will tell you which line of code Python is running.
Running Bit on your own
To get some practice running Bit on your own, create a folder in your
bit. You can do this in PyCharm by right-clicking on the
cs110 folder and selecting
Then create a new file in this folder called
hello_bit.py. You can do this by
right-clicking on the
bit folder and selecting
Then copy and paste the code above into this file.
You should end up with a file like this:
To run this code, you need to install the
byubit library. See the
Installing Bit guide if you haven’t done this
Running the program
Now you can run this code on your own. Click the green triangle next to the line
of code that starts with
Run 'hello_bit'. You should see what we showed you above:
Explaining the rest of this code
Let’s go through this code line by line.
Whenever you write a program that uses Bit, you need to start with this line:
from byubit import Bit
This is a way of telling Python that you want to use the
byubit library that
you installed. You will use
Bit with a capital
B for special commands
telling the library what to do.
Lines 4 to 16
Lines 4 to 16 contain a function called
@Bit.empty_world(5, 3) def move_around(bit): bit.move() bit.move() bit.paint("red") bit.left() bit.move() bit.paint("green") bit.right() bit.move() bit.paint("blue")
@Bit.empty_world(5, 3)— This is a decorator that tells
Bitto start in an empty world that is
5squares wide and
def move_around(bit):— This is a function definition. Everything we will do this semester will involve writing Python functions.
6 to 16 — This is the function body. The function body will be run every time you call the function.
A function has five parts to it:
defkeyword tells Python you are defining a function.
The function name tells Python how someone can call this function. Here we have given the function the name
The function arguments are listed in parentheses. Here we tell Python this function takes one argument,
The function definition ends with a colon
The function body is the list of commands you will run when the function is called. These are indented and the indentation is very important. Every line in the function body must be indented the same amount. The usual indentation is four spaces.
Lines 19 and 20
Lines 19 and 20 contain the main block of the Python program:
if __name__ == '__main__': move_around(Bit.new_bit)
Every program has to start somewhere. In Python, we call this the main block. This is where Python starts when it runs your code. Python will put a green triangle to the left of your main block so that you can click on it to run your program.
In this main block, we have one line of code:
Here we are calling the
move_around() function. We have to give it a bit,
and we do this by saying
Bit.new_bit. This creates a new bit to live in the
Defining versus calling a function
When we define a function with
def, we are telling Python what a function
means. For example, when we defined
move_around() we told Python this means
move Bit two squares, turn left, move another square, paint red, and so forth.
When we call a function, we are telling Python to run all of the code in the function definition. This is when Python will actually run all of the code that tells Bit what to do.
Python needs blank lines to separate pieces of the code. The convention is to use two blank lines between every piece. If you do not follow this convention, PyCharm will complain by putting a squiggly line underneath the line that doesn’t have enough blank lines before it.
Add an extra blank line and the warning will go away.