Due: Tuesday 5 February
The reading for this assignment is Chapters 4-6 of
How to think..., but you should avoid reading Chapter 4
until you have finished Section 2.1.
To turn in this homework, please add polygon.py and
your modified version of Wanderer.py to your repository
and check them in.
Encapsulation and Generalization
- We have already seen two ways to draw a square. Here
is a third:
bob = Turtle(world)
for i in range(4):
Create a file named polygon.py and type in this code.
Run it and confirm that it draws a square.
- Encapsulate this code in a function called square
and write a line of code that invokes it. TIP: when you change
your program, you should be able to run the new version without
- Generalize the function so that it takes a turtle and a
distance, dist, as parameters.
- Generalize the function so that it takes an additional
parameter, n, and draws an n-sided regular polygon. You might
want to change the name of the function to polygon. Hint: lt and rt take an optional second argument that specifies the
number of degrees to turn. Another hint: The angles of an n-sided
regular polygon are degrees.
- Write a function called circle that takes a turtle, t,
and radius, r, as parameters and that draws an approximate circle
by invoking polygon with an appropriate distance and number of
sides. Test your function with a range of values of r.
Hint: figure out the circumference of the circle and make sure that
dist * n = circumference.
- Make a more general version of circle called arc
that takes an additional parameter theta, which determines
what fraction of a circle to draw. theta is in units of
degrees, so when theta=360, arc should draw a complete
- Chances are that when you started to write arc you realized
that you weren't able to reuse polygon, even though arc
and polygon are very similar. Maybe you ended up doing `design
by copy and paste.' If so, then you end up with two very similar
chunks of code; if you want to make changes later, you will find
yourself making every change twice.
Refactor the program so that arc,
circle, and polygon all invoke a single (very general)
- Write an appropriately general function called flower that
can draw flowers like this:
- As usual, you should look over your code to see if
there are opportunities to make it better, and add comments
that explain what each function does, and that explain anything
that is not obvious. Add a comment at the beginning that has
your name in it. Print a copy of the code and, if you make
a flower you are proud of, a copy of the output (by hitting
Print Canvas and then typing
- Download and run Wanderer.py:
Print a copy of the code (a2ps -1 Wanderer.py) and read it
over. It uses some features we haven't studied yet, but you should
be able to understand enough to modify it.
- The distance function is not implemented correctly.
You should change it so that it actually computes the distance
from the given turtle, self, to the origin.
- One problem with Wanderers is that they eventually go off the
screen, and they usually don't come back. One way you might try to
solve this problem is to modify step so that if a Wanderer is
too far from the origin, it turns around.
Make this change and run the program again. Does it work? (You
might want to draw a circle at the appropriate radius).
- Think of a way to keep the Wanderers in bounds. Ideally
your algorithm should be simple (easy to implement), effective
(it should keep the Wanderers in bounds), and gentle (it shouldn't
cause the Wanderers to behave too erratically near the boundary).
- Prepare and print your code as usual.
The following exercises are optional. You don't have to turn
them in, but if you do something cool, I would be happy to see it.
- Modify step so that Wanderers `orbit;' that is, so
they try to stay the same distance from the origin.
- Modify step so that Wanderers interact with each other.
For example, you could have them run after each other, or avoid
each other, or bounce off each other when they collide. World
objects have an attribute called animals that is a list
of the animals that are currently in the world.
- Create different kinds of Turtles (not just Wanderers) that
have different definitions of step. You could have one kind
that runs after other turtles, and another kind that runs away.
- Make Turtles behave like a paintbrush.
- Add a Turtle attribute named thickness that controls
the thickness of the line.
- Modify World.py so that when a
Turtle moves, the thickness of the line is the turtle's thickness.
- Modify step so that it reduces the thickness each time the
- Write a function called dip that resets the
- Add a dip button to the Turtle Control Panel
- Use Turtles to make calligraphy.
- ... square
- You might find
it helpful to put your code in a file named turtle_code.py,
because that's what World.py runs by default. But when you
are done, please put your solution in polygon.py.