Page Title

Tutorial 4

Python with turtle

The above animation written in turtle. Let's learn how to make this. At the end you will see full code.

Overview

turtle is a pre-installed Python library that enables users to create pictures and shapes by providing them with a virtual canvas.

Python turtle library helps new programmers get a feel for what programming with Python is like in a fun and interactive way.

With the Python turtle library, you can draw and create various types of shapes and images.

Getting Started With turtle

To do work with turtle you need to know :

1 - Python Environment - You can use applications like IDLE or Jupyter Notebook to program with turtle. However, if you’re not comfortable with them, then you can program with the REPL
2 - Python Version: Ensure that you have version 3 of Python on your computer. If not, then you can download it from the Python website.

Note : You don’t need to install any new packages. All you need to do is import the library into your Python environment

The Python turtle library contains all the methods and functions that you’ll need to create your images. To access a Python library, you need to import it into your Python environment, like this:

>>> import turtle

turtle is a graphical library, which means you’ll need to create a separate window (called the screen) to carry out each drawing command. You can create the screen by initializing a variable for it.

Now, to open the turtle screen, you initialize a variable for it in the following way:

>>> s = turtle.getscreen()

Screen panel will open like this :

Next, you need to initialize the variable t, which you’ll then use throughout the program to refer to the turtle:

>>> t = turtle.Turtle()

You now have your screen and your turtle. The screen acts as a canvas, while the turtle acts like a pen. You can program the turtle to move around the screen.

The turtle has certain changeable characteristics, like size, color, and speed. It always points in a specific direction, and will move in that direction unless you tell it.

Moving the Turtle

There are four directions that a turtle can move in:

Forward
Backward
Left
Right

The turtle moves .forward() or .backward() in the direction that it’s facing. You can change this direction by turning it .left() or .right() by a certain degree.

Command :

>>> t.right(90)
>>> t.forward(100)
>>> t.left(90)
>>> t.backward(100)

When you run these commands, the turtle will turn right by 90 degrees, go forward by a 100 units, turn left by 90 degrees, and move backward by a 100 units.

You can use the shortened versions of these commands as well:

t.rt() instead of t.right()
t.fd() instead of t.forward()
t.lt() instead of t.left()
t.bk() instead of t.backward()

You can also draw a line from your current position to any other arbitrary position on the screen. This is done with the help of coordinates.

The point where the turtle is initially positioned at the beginning of your program is (0,0). This is called Home.

To move the turtle to any other area on the screen, you use .goto() and enter the coordinates like this:

>>> t.goto(100,100)

To bring the turtle back to its home position, you can type this command :

>>> t.home()

This is like a shortcut command that sends the turtle back to the point (0,0).

Drawing a Shape

You can draw different shapes and images. You can draw polygon using the below command.

>>> t.fd(100)
>>> t.rt(90)
>>> t.fd(100)
>>> t.rt(90)
>>> t.fd(100)
>>> t.rt(90)
>>> t.fd(100)

Drawing Preset Figures

If you want to draw a circle then you can use below command:

>>> t.circle(60)

The number within the brackets is the radius of the circle. You can increase or decrease the size of the circle by changing the value of its radius.

You can also draw a dot using the below command:

>>> t.dot(60)

The number within the brackets is the diameter of the dot. Just like with the circle, you can increase or decrease the size of the dot by changing the value of its diameter.

Changing the Screen Color

By default, turtle always opens up a screen with a white background. However, you can change the color of the screen at any time using the following command:

>>> t.bgcolor("blue")

You can replace "blue" with any other color.

You can use a variety of colors for your screen just by typing in their hex code number.

Changing the Screen Title

You can change the title of your screen with the help of this command:

>>> t.title("Hello Sololearner")

Changing the Turtle Size

You can increase or decrease the size of the onscreen turtle using shapesize to make it bigger or smaller. This changes only the size of the shape without affecting the output of the pen as it draws on the screen.

Try typing in the following commands:

>>> t.shapesize(1,5,10)
>>> t.shapesize(10,5,1)
>>> t.shapesize(1,10,5)
>>> t.shapesize(10,1,5)

The numbers given are the parameters for the size of the turtle:

Stretch length – positive number
Stretch width – positive number
Outline width – positive number

You can change these according to your preference.

Color control

You can change the color of the pen using the below command:

>>> t.pencolor("green")

You can Set pencolor to the RGB color represented by the tuple of r, g, and b. Each of r, g, and b must be in the range 0..colormode, where colormode is either 1.0 or 255

If turtleshape is a polygon, the outline of that polygon is drawn with the newly set pencolor.

You change the color of the turtle (or the fill), you can type the following command:

>>> t.fillcolor("red")

To change the color of both, you can type the following command:

>>> t.color("red", "violet")

Filling

The Python turtle library gives you the option to add color to your drawings. There is some function which can use to do this like :

filling() - Return fillstate (True if filling, False else)
begin_fill() - To be called just before drawing a shape to be filled.
end_fill() - Fill the shape drawn after the last call to begin_fill().

Whether or not overlap regions for self-intersecting polygons or multiple shapes are filled depends on the operating system graphics, type of overlap, and number of overlaps.

>>> import turtle
>>> s = turtle.getscreen()
>>> t = turtle.Turtle()

>>> t.color("green", "red")
>>> t.begin_fill()
>>> t.circle(80)
>>> t.end_fill()

When we use .begin_fill(), we’re telling our program that we’re going to be drawing a closed shape which will need to be filled in. Then, we use .end_fill() to indicate that we’re done creating our shape and it can now be filled in.

More drawing control

1 - reset()

Delete the turtle’s drawings from the screen, re-center the turtle and set variables to the default values.

>>> t.reset()

This clears the screen and takes the turtle back to its home position. Your default settings, like the turtle’s size, shape, color, and other features, will also be restored.

2 - clear()

Delete the turtle’s drawings from the screen. Do not move turtle. State and position of the turtle as well as drawings of other turtles are not affected.

>>> t.clear()

3 - Undoing Changes

The Python turtle library gives you the option to undo what you’ve done. If you want to undo the very last thing you did, then type in the following:

>>> t.undo()

Appearance

turtle.shape(name=None)

The initial shape of the turtle isn’t really a turtle, but a triangular figure. However, we can change the way the turtle looks, and we do have a couple of options when it comes to doing so.

We can use following polygon shapes: "arrow", "turtle", "circle", "square", "triangle", "classic".

>>> t.shape("turtle")
>>> t.shape("arrow")
>>> t.shape("circle")
>>> t.shape("square")
>>> t.shape("triangle")
>>> t.shape("classic")

turtle.resizemode(rmode=None)

Set resizemode to one of the values: "auto", "user", "noresize". If rmode is not given, return current resizemode. Different resizemodes have the following effects:

auto : adapts the appearance of the turtle corresponding to the value of pensize.
user : adapts the appearance of the turtle according to the values of stretchfactor and outlinewidth (outline), which are set by shapesize().
noresize : no adaption of the turtle’s appearance takes place.

>>> t.resizemode("auto")
>>> t.resizemode("user")
>>> t.resizemode("noresize")

Changing the Pen Speed

The turtle generally moves at a moderate pace. If you want to decrease or increase the speed to make your turtle move slower or faster, then you can do so by typing the following:

>>> t.speed(1)
>>> t.forward(100)
>>> t.speed(10)
>>> t.forward(100)

This code will first decrease the speed and move the turtle forward, then increase the speed and move the turtle forward again.

The speed can be any number ranging from 0 (the slowest speed) to 10 (the highest speed).

If input is a number greater than 10 or smaller than 0.5, speed is set to 0. Speedstrings are mapped to speedvalues as follows:

"fastest": 0
"fast": 10
"normal": 6
"slow": 3
"slowest": 1

Speeds from 1 to 10 enforce increasingly faster animation of line drawing and turtle turning.

speed = 0 means that no animation takes place. forward/back makes turtle jump and likewise left/right make the turtle turn instantly.

Pen control

Sometimes, you may want to move your turtle to another point on the screen without drawing anything on the screen itself. To do this, you use .penup(). Then, when you want to start drawing again, you use .pendown().

turtle.pendown() / turtle.pd()

Pull the pen down – drawing when moving.

turtle.penup() / turtle.pu()

Pull the pen up – no drawing when moving.

You can try the below code:

>>> t.fd(100)
>>> t.rt(90)
>>> t.penup()
>>> t.fd(100)
>>> t.rt(90)
>>> t.pendown()
>>> t.fd(100)
>>> t.rt(90)
>>> t.penup()
>>> t.fd(100)
>>> t.pendown()

Animation control

turtle.delay(delay=None)

Set or return the drawing delay in milliseconds. (This is approximately the time interval between two consecutive canvas updates.) The longer the drawing delay, the slower the animation.

>>> t.delay(5)

turtle.tracer(n=None, delay=None)

Turn turtle animation on/off and set delay for update drawings. If n is given, only each n-th regular screen update is really performed. (Can be used to accelerate the drawing of complex graphics.) When called without arguments, returns the currently stored value of n. Second argument sets delay value (see delay()).

>>> t.tracer(8, 25)

turtle.update()

Perform a TurtleScreen update. To be used when tracer is turned off.

Full code of the SOLOLEARN Animation

Click here

import turtle
t = turtle.Turtle()

window = turtle.Screen()
window.bgcolor("grey")

t.shape("turtle")
t.pensize(3)
t.speed(4)
t.color('purple')
t.delay(5)

#S
t.pendown()
t.fd(20)
t.lt(90)
t.fd(20)
t.lt(90)
t.fd(20)
t.rt(90)
t.fd(20)
t.rt(90)
t.fd(20)

t.penup()
t.goto(40,40)

t.color('red')

t.delay(50)

#O
t.pendown()
t.rt(90)
t.fd(40)
t.lt(90)
t.fd(20)
t.lt(90)
t.fd(40)
t.lt(90)
t.fd(20)

t.penup()
t.goto(80,40)

t.color('blue')

t.delay(20)

#L
t.pendown()
t.lt(90)
t.fd(40)
t.lt(90)
t.fd(20)

t.penup()
t.goto(120,40)

t.color('red')

#O
t.pendown()
t.rt(90)
t.fd(40)
t.lt(90)
t.fd(20)
t.lt(90)
t.fd(40)
t.lt(90)
t.fd(20)

t.penup()
t.goto(0,-40)

t.color('blue')
t.delay(50)

#L
t.pendown()
t.lt(90)
t.fd(40)
t.lt(90)
t.fd(20)

t.penup()
t.goto(40,-40)

t.color('green')

#E
t.pendown()
t.fd(20)
t.lt(180)
t.fd(20)
t.lt(90)
t.fd(20)
t.lt(90)
t.fd(20)
t.lt(180)
t.fd(20)
t.lt(90)
t.fd(20)
t.lt(90)
t.fd(20)

t.penup()
t.goto(80, -40)

t.color('yellow')
t.delay(5)

#A
t.pendown()
t.rt(90)
t.fd(40)
t.bk(40)
t.lt(90)
t.fd(20)
t.rt(90)
t.fd(20)
t.rt(90)
t.fd(20)
t.bk(20)
t.lt(90)
t.fd(20)

t.penup()
t.goto(120, -40)

t.color('brown')

#R
t.pendown()

t.fd(40)
t.bk(40)
t.lt(90)
t.fd(20)
t.rt(90)
t.fd(20)
t.rt(90)
t.fd(20)
t.lt(135)
t.fd(30)
t.rt(45)

t.penup()
t.goto(160,-40)

t.color('black')

#N
t.pendown()
t.fd(40)
t.bk(40)
t.lt(30)
t.fd(45)
t.lt(150)
t.fd(40)

t.penup()
t.goto(200, -40)

t.done()
t.hideturtle()

Let's know about the functions in short.

bgcolor - This is used to set background color of window.
shape - This is used to change the icon of turtle.
pensize - This is used to set the line thickness to width. You can change according to you.
speed - Set the turtle’s speed to an integer value in the range 0..10.
color - Set pencolor and fillcolor.
delay - Set or return the drawing delay in milliseconds. (This is approximately the time interval between two consecutive canvas updates.)
fd - It's a short form of forward which is used to move turtle in forward direction.
bk - It's a short form of backward which is used to move turtle in backward direction.
lt - It's a short form of left. Turn turtle left by angle units
rt - It's a short fprm of right. Turn turtle right by angle units.
penup - Pull the pen up – no drawing when moving.
pendown - Pull the pen down – drawing when moving.
goto -Move turtle to an absolute position. If the pen is down, draw line. Do not change the turtle’s orientation.
done - Must be the last statement in a turtle graphics program.
hideturtle - Make the turtle invisible.

To be continue for more...

Tutorial 4 - Python with turtle (Animation)