Turtle graphics: drawing with loops, and the 360 rule

A robot with a pen#

Picture a small robot sitting on a big sheet of paper, holding a pen against it. You can only give it simple orders: walk forward 100 steps, turn left 90 degrees, lift the pen, put the pen down. Wherever it walks with the pen down, it leaves a line.

That robot is Python’s turtle, from the turtle module that comes with most Python installs. (On some Linux systems the graphics package it needs, tkinter, is installed separately.) Courses use it early for two reasons. A loop that repeats is suddenly something you can watch, and a mistake in it is a wrong picture you can see at a glance. And the turtle is an object: a thing in your program that has its own data (where it is, which way it faces, whether its pen is down) and its own actions, called methods, that you call with a dot, like t.forward(100).

Setting up: the screen and the turtle#

Every turtle program has the same frame:

import turtle              # load the module

screen = turtle.Screen()   # the window and the paper
t = turtle.Turtle()        # one turtle object, named t

# ... drawing commands go here ...

turtle.done()              # keep the window open until you close it

The paper is a grid. The turtle starts in the centre, at coordinates (0, 0), facing right (east). The x value grows to the right and y grows upwards, as in maths class. Turning left is anticlockwise; right is clockwise. Without turtle.done() at the end, the window can close the moment the program finishes, before you see anything; inside some editors, such as IDLE, it stays open anyway, which is why the bug comes and goes.

Moving, turning and lifting the pen#

import turtle

t = turtle.Turtle()
for i in range(3):
    t.forward(40)
    t.left(90)
    t.forward(40)
    t.right(90)

t.penup()
t.goto(0, -60)
t.pendown()
t.forward(120)

turtle.done()

Three steps drawn, then the pen lifted, a jump to a new spot, and the pen put down to draw a final line. The gap in the picture is the penup. Note that left and right only turn: if you forget a forward, nothing appears for that step.

Loops and the 360 rule#

A square is “forward, turn left 90”, four times. That repetition is a for loop:

import turtle

t = turtle.Turtle()
for side in range(4):
    t.forward(100)
    t.left(90)

turtle.done()

Why 90? Walk all the way round any closed shape and you end up facing the way you started: a full turn of 360 degrees, shared equally between the corners. So the rule for a regular shape with n sides is: turn 360 / n at every corner. Square: 360 / 4 = 90. Triangle: 360 / 3 = 120. Hexagon: 360 / 6 = 60.

The classic mistake is to turn by the angle inside the corner. A triangle’s inside angles are 60 degrees, so it is tempting to write left(60):

import turtle

t = turtle.Turtle()
for side in range(3):
    t.forward(100)
    t.left(60)

turtle.done()

Turning 60 three times is only 180 degrees in total, so the turtle has turned half way round and the shape never closes. With 120, the turn the turtle actually makes (the outside angle), it does:

import turtle

def polygon(t, n, size):
    for side in range(n):
        t.forward(size)
        t.left(360 / n)

t = turtle.Turtle()
x = -260
for n in [3, 4, 5, 6]:
    t.penup()
    t.goto(x, 0)
    t.pendown()
    polygon(t, n, 70)
    x = x + 140

turtle.done()

One function with a loop inside draws every one of those shapes. The sides and the turn both come from n, so changing one number changes the shape.

Colour, thickness and fill#

import turtle

t = turtle.Turtle()
t.pensize(4)
t.color("navy", "gold")
t.begin_fill()
for side in range(4):
    t.forward(100)
    t.left(90)
t.end_fill()

t.penup()
t.goto(200, 0)
t.pendown()
t.color("darkred", "salmon")
t.begin_fill()
t.circle(50)
t.end_fill()

turtle.done()

The fill needs both calls. Call begin_fill, draw a closed outline, then end_fill, and the inside is painted. Forget end_fill and no fill appears at all.

Functions, and loops inside loops#

Once a shape is in a function, a second loop can repeat the whole shape. Draw a square, turn a little, draw another square, and so on: the outer loop runs 12 times and the inner loop (inside square) runs 4 times for each, so the turtle draws 48 sides in all.

import turtle

def square(t, size):
    for side in range(4):
        t.forward(size)
        t.left(90)

t = turtle.Turtle()
t.speed(0)
for i in range(12):
    square(t, 80)
    t.left(30)

turtle.done()

The function takes the turtle as a parameter (t), so the same function can draw with any turtle you hand it. The outer turn is 360 / 12 = 30: the same 360 rule, applied to the whole pattern.

Several turtles: objects and their own state#

Each call to turtle.Turtle() makes a brand-new turtle object with its own position, heading, colour and pen. These are called instances: separate objects made from the same blueprint. Moving one never moves another:

import turtle

ana = turtle.Turtle()
ben = turtle.Turtle()
ana.color("teal")
ben.color("purple")
ana.pensize(3)
ben.pensize(3)

ben.left(90)
for i in range(4):
    ana.forward(60)
    ana.left(45)
    ben.forward(60)
    ben.right(45)

turtle.done()

ana and ben share nothing but the paper. Each method call goes to the object named before the dot. That is the habit the turtle is quietly teaching: ana.forward(100) means “ana, walk forward”, exactly as name.upper() later means “this string, give me an uppercase copy”.

A turtle can also tell you its state: t.position() returns its coordinates and t.heading() its direction. After the square earlier, printing t.position() shows (-0.00,0.00) and t.heading() shows 0.0: a closed shape brings the turtle back to where it started, facing the same way. (We checked by running it. The minus sign is a tiny rounding leftover from the turning maths, a number like -0.00000000000001 printed to two decimal places.)

Where these go wrong#

• Turning by the inside angle. A triangle needs left(120), not left(60). Turn 360 / n.
• Naming your own file turtle.py. import turtle then imports your file instead of Python’s module, and the program fails with AttributeError: partially initialized module 'turtle' has no attribute 'Turtle' (most likely due to a circular import). (Python 3.13 and later word it differently and suggest renaming the file.) Rename the file, and delete any turtle.py copy left in the folder.
• Forgetting turtle.done(). The window may vanish as soon as the drawing finishes.
• Writing t.Forward(100) or turtle.turtle(). Method names are lowercase; the class is Turtle with a capital T. Both mistakes raise AttributeError.
• Drawing while moving to a new start point. Put penup() before goto and pendown() after.
• Calling begin_fill without end_fill. The shape is never filled.
• Expecting y to grow downwards. In turtle graphics, positive y is up and (0, 0) is the centre of the window.

Practice#

Answer each one on paper before you look at the solutions. Every answer that involves running code was checked by running it.

1. A turtle starts at (0, 0) facing east. It runs forward(50), left(90), forward(30). Where is it, and which way does it face?
2. How many degrees should the turtle turn at each corner of a regular pentagon, a regular octagon and a regular 10-sided shape?
3. Using the polygon(t, n, size) function from this guide, write the code to draw an octagon with sides of 50.
4. This code is meant to draw a triangle but does not. Explain what it draws and fix it.

   for side in range(3):
       t.forward(100)
       t.left(60)

5. A five-pointed star is drawn with five lines, turning right 144 degrees after each. Explain why 144 works, then write the loop.
6. You make two turtles, a = turtle.Turtle() and b = turtle.Turtle(), then call a.left(90). Which way does b face? What does this show?

Solutions#

1. At (50, 30), facing north (heading 90). The first move goes 50 to the right; the left turn makes it face up; the second move goes 30 up.
2. 360 / 5 = 72, 360 / 8 = 45 and 360 / 10 = 36.
3. Pass 8 for n; the function works out the 45-degree turn itself:

   import turtle
   
   def polygon(t, n, size):
       for side in range(n):
           t.forward(size)
           t.left(360 / n)
   
   t = turtle.Turtle()
   polygon(t, 8, 50)
   
   turtle.done()

4. It turns only 3 × 60 = 180 degrees in total, so the shape never closes: it draws three sides of a hexagon. Change the turn to t.left(120), which is 360 / 3.
5. A star’s path goes round the centre twice before it closes, so its five turns add up to 720 degrees, and 720 / 5 = 144.

   import turtle
   
   t = turtle.Turtle()
   for point in range(5):
       t.forward(150)
       t.right(144)
   
   turtle.done()

6. b still faces east (heading 0). Each turtle is a separate object with its own state; a method call changes only the object named before the dot.

Test-readiness checklist#

These are the skills a first programming course tests on this topic. Tick each one only when you can do it without looking.

• ☐  I can set up a turtle program: import, Screen, Turtle, and turtle.done().
• ☐  I can predict a turtle’s position and heading after a few moves, using the centre-origin, y-up grid.
• ☐  I can draw any regular polygon with a loop, turning 360 / n each time.
• ☐  I can lift and lower the pen, move with goto, and set colour, pen size and fill.
• ☐  I can write a drawing function that takes the turtle as a parameter, and nest loops to repeat a shape.
• ☐  I can explain what an object, a method and an instance are, using two turtles as the example.

Frequently asked questions#

Something here not clear? A topic you wish we covered? Tell us. We read every message, and a request is the fastest way to get a guide written — several of these exist because somebody asked.