Recently, I was working on a Python Turtle graphics project where I needed to control how fast the animations were running. The issue is, getting the right speed can make a huge difference in how your turtle graphics appear to users.
In this article, I’ll cover everything you need to know about controlling the speed of your turtle in Python with practical examples.
So let’s start..
Understand Turtle Speed in Python
The turtle module in Python has a built-in speed feature that lets you control how fast your turtle moves across the screen. This is especially useful when you’re creating animations or drawings where timing matters.
Speed values in Python Turtle range from 0 to 10, with some special behaviors:
- 0: This is the fastest speed – no animation, just immediate results
- 1: This is the slowest speed
- 2-10: Gradually faster speeds
- The default speed is 3 if not specified
Read Python Turtle Pen
Method 1: Set Turtle Speed with the speed() Method
The most direct way to control your turtle’s speed is with the speed() method. Here’s how to use it:
import turtle
# Create a turtle object
t = turtle.Turtle()
# Set the turtle's speed (0-10)
t.speed(1) # Slowest speed
# Draw a square
for _ in range(4):
t.forward(100)
t.right(90)
turtle.done()You can see the output in the screenshot below.
In this example, I’ve set the speed to 1 (the slowest). This is great when you want to show the drawing process step by step, perhaps for educational purposes.
Let’s try the fastest speed:
import turtle
t = turtle.Turtle()
t.speed(0) # Fastest speed - instant drawing
# Draw a more complex shape
for _ in range(36):
t.forward(100)
t.right(170)
turtle.done()With speed 0, the drawing appears almost instantly, perfect for complex patterns where you care about the result, not the animation.
Check out Python Turtle Grid
Method 2: Change Speed During Execution
One thing I love about turtle speed is that you can change it dynamically during your program’s execution:
import turtle
t = turtle.Turtle()
# Start slow
t.speed(1)
t.color("blue")
# Draw first part slowly
for _ in range(4):
t.forward(50)
t.right(90)
# Speed up for the complex part
t.speed(8)
t.color("red")
# Draw second part faster
for _ in range(36):
t.forward(5)
t.right(10)
turtle.done()You can see the output in the screenshot below.
This technique is particularly useful when you want to emphasize certain parts of your drawing by slowing down, then speeding through repetitive or less important sections.
Read Draw a Flower in Python Turtle
Method 3: Use delay() for Fine-Tuned Control
For even more control over animation timing, you can use the delay() function:
import turtle
screen = turtle.Screen()
# Set delay in milliseconds
screen.delay(20) # 20 milliseconds between updates
t = turtle.Turtle()
t.speed(6)
# Draw a spiral
for i in range(100):
t.forward(i)
t.right(45)
turtle.done()You can see the output in the screenshot below.
Python’s delay() function controls how many milliseconds the screen waits between updates. Lower values make animations smoother but more processor-intensive.
Check out Python Turtle Star
Speed Values and Their Use Cases
Different speed values work better for different scenarios. Here’s my guide based on years of working with Turtle graphics:
- Speed 0 (Fastest): Best for complex drawings where animation isn’t important
- Speed 1-3 (Slow): Perfect for educational demonstrations or when explaining the logic of a drawing
- Speed 4-7 (Medium): Good balance for most projects
- Speed 8-10 (Fast): Useful for more complex animations where you still want to see movement
- Dynamic Speed: Changing speeds during execution provides emphasis on important parts
Read Python Turtle Oval
Create a US Map Outline with Variable Speeds
Let’s put this knowledge to work with a practical example – drawing a simplified outline of the United States with different speeds for different sections:
import turtle
def draw_us_outline():
screen = turtle.Screen()
screen.title("US Map Outline")
screen.bgcolor("lightblue")
t = turtle.Turtle()
t.pensize(2)
t.color("navy")
# Start with East Coast (slower to show detail)
t.penup()
t.goto(100, 0)
t.pendown()
t.speed(3)
# Draw East Coast with curves
t.setheading(90) # North
t.forward(80)
t.left(30)
t.forward(50)
t.right(40)
t.forward(60)
# Speed up for straight sections
t.speed(8)
# Draw northern border
t.setheading(180) # West
t.forward(200)
# Slow down for West Coast detail
t.speed(3)
# Draw West Coast with curves
t.setheading(-120)
t.forward(60)
t.left(20)
t.forward(70)
# Speed up for southern border
t.speed(8)
t.setheading(0) # East
t.forward(200)
t.hideturtle()
turtle.done()
draw_us_outline()In this example, I’ve slowed down the turtle when drawing the more detailed coastal regions and sped it up for the straighter border sections. This helps emphasize the complex coastal features while moving quickly through the simpler parts.
Read Python Turtle Cheat Sheet
When to Avoid Using Speed(0)
While speed(0) is great for instant results, I’ve found it’s not always the best choice:
- Educational settings: Students miss seeing how the drawing is constructed
- Debugging: It’s harder to spot where things go wrong
- Presentations: Audiences often appreciate seeing the drawing process
Tips for Optimizing Turtle Speed Performance
Over the years, I’ve discovered some techniques to get the best performance from Turtle graphics:
- Use
tracer(False)for ultimate speed: For extremely complex drawings, you can turn off animation completely:
screen = turtle.Screen()
screen.tracer(False)
# Draw your complex shape here
screen.tracer(True) # Turn updates back on
screen.update() # Force a screen update- Minimize pen movements: The more you lift and lower the pen, the slower your program
- Batch similar operations: Draw all lines of the same color together rather than switching colors frequently
- Use
turtle.done()instead ofinput()to keep the window open: It’s more efficient
I hope you found this article helpful for controlling the speed of your turtle graphics in Python. Whether you’re creating educational tools, data visualizations, or just having fun with graphics, mastering speed control can take your turtle projects to the next level.
Other Python articles you may also like:
I am Bijay Kumar, a Microsoft MVP in SharePoint. Apart from SharePoint, I started working on Python, Machine learning, and artificial intelligence for the last 5 years. During this time I got expertise in various Python libraries also like Tkinter, Pandas, NumPy, Turtle, Django, Matplotlib, Tensorflow, Scipy, Scikit-Learn, etc… for various clients in the United States, Canada, the United Kingdom, Australia, New Zealand, etc. Check out my profile.
