Some of you may have encountered the Logo programming language or one of its many offshoots. A memorable aspect of Logo was its use of turtle graphics — a form of vector graphics similar to pen plotters. Notably, turtle graphics features a relative drawing cursor.

Standard Python includes a turtle graphics module. It doesn’t have a huge production value (there’s no easy way to save an image, for instance), but it can be fun to play with.

We can compare turtle graphics to the old Etch A Sketch toys. Those mechanical drawing devices had two knobs, one that controlled horizontal movement of the drawing cursor, and one that controlled vertical movement. Drawing diagonal lines required small steps of horizontal and vertical to create the desired diagonal.

Turtles can move in any direction at any angle, but what they share in common with the Etch A Sketch is that drawing is always relative from where the cursor is at the moment. Drawing a specific image requires some thinking ahead to plan the lines, since each new line begins where the last one left off.

However, turtle graphics has two features the Etch A Sketch doesn’t. Firstly, you can move the cursor without drawing. Turtles have “pen down” and “pen up” commands that control whether they leave a line or not during movement. Secondly, turtles have commands that can move them instantly (without drawing) to a new point. So, turtles can jump around.

Let’s jump in with the example from the Python documentation for the turtle module:

I added comments and turned it into a callable function with parameters to make it easy to experiment, but it’s functionally the same routine as in the docs. When run, this opens a Tkinter window for drawing. When the drawing is done, closing the window returns control to the Python script.

Note that, because the draw_star function calls the turtle.done method, you cannot call draw_star more than once in the script. Move the done method to the end of the script to allow that. Alternately, leave it off entirely as I have in the examples below. I included it here because the example in the Python docs does. The method is associated with the turtle.mainloop method in the screen events section, so I believe these methods are for implementing interactive windows. None of these examples explore that aspect, so both methods can be ignored here.

Figure 1.

Using the defaults, the image drawn should look like Figure 1.

As mentioned already, there’s no easy way to save an image to file. The simplest recourse is to make a screen capture using whatever tools you have for that.

In Windows, for example, the old [Alt]+[Print Screen] key combo captures the active window to the clipboard, and from there you can paste it into a graphics program you can save it to file from.

Windows also has [⊞]+[Shift]+[S] to bring up the screen capture interface. I haven’t used Apple computers enough to offer any tips on screen capture, but I’m sure there are ways (it’s certainly possible on my iPhone and iPad).

One can use the turtle.getcanvas method to get a reference to the Tkinter Canvas that underlies the Turtle Screen, but obviously this requires knowing how to use Tkinter objects.

One thing you can try with the code above is providing different angles. In particular, note that an angle of 90 draws a square box, an angle of 60 draws a hexagon, and an angle of 45 draws an octagon. Angles close to 180 create stars with lots of sharp points. Don’t be afraid to experiment.

Here’s an example that uses more of the turtle features:

When run, this generates a random walk image (see Figure 2 for an example — the output will be different each time the program is run).

The example shows how to control the heading mode (line #13), window size (line #16), color mode (line #19), angle mode (line #25), speed (line #29), and line width (line #32). Most are self-descriptive. Angle mode for headings is either degrees or radians — each has their own method. Color mode is either 1.0 or 255, which determines whether color values are 0.0-1.0 or 0-255.

Figure 2.

If you play with the Python turtle for very long, you’ll probably end up setting the speed to fastest possible all the time. The slower animation is fun at first, but it gets old if you’re running a pattern repeatedly.

The random walk loop uses a simple implementation of torus mapping. That is, of joining the left-right edges and the top-bottom edges such that running off one edge of the screen “teleports” you to the opposite side.

But you’ll note some incomplete lines with this happens. Fixing it is left as an exercise for the reader, but a hint is that lines that cross the edge need to be drawn twice, once on each side.

Just for fun, when the random walk stops, we put a red dot at the end of the walk, draw a thick blue line back to the start, and draw another dot there. This is just to illustrate how far (or not) the random walk got from the start.

Reader exercise: Make the random walk more interesting by changing the pen color, either at random intervals or continuously over time.

Here’s a function that uses turtle graphics to draw a Sierpiński Triangle:

The turtle drawing code (lines #26 to #55) is much the same as in the previous example. But instead of a loop drawing random segments, the loop is driven by a “drawing program” consisting of “+” and “-” characters that tell the turtle to turn right or left (respectively).

Figure 3.

When run, this generates a Sierpiński Triangle. The levels parameter controls how deep the recursion goes and hence how many sub-triangles the final triangle has.

Figure 3 shows a run with levels=8.

The more levels the triangle has, the larger the larger xmax and ymax have to be. The program prints out the maximum extent the turtle reached to help determine what xmax and ymax need to be. Run once to find those limits; run again with appropriate settings for xmax and ymax.

For example, to generate Figure 3, I needed xmax=26000 and ymax=24000.

Note that, as written, an odd number of levels draws the triangle upside down, so ymax needs to be negative. Also note that doing this inverts the Y-axis and the triangle is drawn right-side-up.

Ideally, one should link the levels parameter to a table of correct coordinates for that level so sizing can happen automatically. This is left as an exercise for the reader.

Turtle graphics are a natural fit for drawing Euler Spirals, which are defined as a series of moves and turns [for more, see Euler Spirals and Pi Paths]:

Most of the code is setup as in previous examples. There is also code to track how var the turtle goes (line #24 and #37-#41). The part that does the drawing (lines #27 to #34) is very simple and roughly resembles the random walk code above. The difference is that, rather than a random angle to turn, the function takes an angle parameter, theta, which it progressively multiplies by itself to get an infinite series of growing angles:

theta, 2×theta, 3×theta, 4×theta, 5×theta, … n×theta, for a sequence with n steps.

Because angles have a 360° modulus, the series wraps around. For example, if theta=45° (a very large angle that doesn’t give an interesting spiral — try it), the series runs:

45°, 90°, 135°, 180°, 225°, 270°, 315°, 0°, 45°, 90°, … for however many steps.

Figure 4.

When run as shown above with a theta of 1.123456789, the result is Figure 4.

The result is a series of spirals that are extremely sensitive to the input angle, theta. Readers are encouraged to experiment with tiny changes between 1.0 and 2.0.

For one example, try theta=1.1010101 and steps=3000. You’ll also need to set xmin=-2000, xmax=2000, ymin=0, and ymax=4000.

For another, try theta=1.0101010 and steps=4000 (with xmin=-2000, xmax=2000, ymin=-2000, and ymax=2000). You’ll find that this creates a symmetrical pattern, and the turtle follows this over and over forever. The complete pattern is drawn after 3000 steps. Setting it to 4000 lets you confirm the turtle is definitely retracing its steps.

The post I linked to above has many more examples you can try.

The last example is a test platform for experimenting:

It also shows how you can use a small simple program to control the turtle rather than hand-coding a routine to draw what you want. You can expand on the concept to include other turtle commands of interest for your application.

The drawing function (lines #7 to #73) takes a list of command tuples where the first element is a command. The match structure (lines #32 to #54) acts on this command element to execute the requested turtle command.

One new wrinkle in this example is the turtle.setup method, which allows setting the window size. This is different from the turtle.setworldcoordinates method which sets the coordinate mapping of the window. Note how we’re setting the window size to 1500×1000 pixels, but the coordinates run from -2000 to +2000 on the X-axis and from -1500 to +1500 on the Y-axis.

Figure 5.

Lines #79 to #92 contain a simple program to draw a box, a diamond, and a horizontal line (see Figure 5).

Note how the turtle commands use the coordinate mapping. The blue box is from -2000 to +2000 on the X-axis and from -1500 to +1500 on the Y-axis. But the window is 1500 pixels by 1000 pixels.

Be sure to use the turtle.setworldcoordinates method after setting other parameters to ensure the coordinate mapping isn’t inadvertently changed.

These should give you a good start on exploring Python Turtle. Have fun!

Link: Zip file containing all code fragments used in this post.

∅