Creating A Bush With Python Turtle: A Beginner's Guide

Python's Turtle module is a fun and interactive way to introduce programming concepts to beginners. It provides a drawing board-like feature, which lets us command a turtle to draw all over it. The on-screen pen that is used for drawing is called the turtle and can be moved using functions like turtle.forward() and turtle.left. The turtle module can be used in both object-oriented and procedure-oriented ways.

To make a bush in Python Turtle, you can use loops to draw multiple lines and create a bushy effect. Here's an example code snippet to get you started:

python

import turtle

Create a new turtle object

turtle.Turtle()

Set the colour of the turtle

turtle.color(green)

Move the turtle forward and change direction to create a bushy effect

for i in range(10):

turtle.forward(50)

turtle.right(90)

turtle.forward(50)

turtle.left(90)

Keep the turtle window open

turtle.done()

In this code, we first import the turtle module and create a new turtle object. We then set the colour of the turtle to green. Inside the for loop, we move the turtle forward, change its direction, and repeat this process to create multiple lines that give the appearance of a bush. Finally, we use turtle.done() to keep the turtle window open until it is manually closed.

You can further customise your bush by changing the colour, the number of lines, the length of the lines, and the angle of direction change.

Turtle's movement in four directions

Turtle Movement in Four Directions

The Python Turtle library allows users to create pictures and shapes using a virtual canvas. The onscreen pen that you use for drawing is called the turtle, and it always points in a specific direction. The turtle can move in four directions: forward, backward, left, and right.

Forward and Backward

The turtle moves forward or backward in the direction it is facing. The distance it moves can be specified as an argument to the function call. For example, to move the turtle forward by 100 pixels, you can use the command:

Python

Turtle.forward(100)

Similarly, to move the turtle backward by a certain distance, you can use the `backward() or `back() function. For example:

Python

Turtle.backward(50)

Left and Right

The turtle can turn left or right by a specified number of degrees. For example, to turn the turtle left by 90 degrees, you can use the command:

Python

Turtle.left(90)

Similarly, to turn the turtle right by a certain number of degrees, you can use the `right() function. For example:

Python

Turtle.right(45)

You can also use the shortened versions of these commands, such as `rt() instead of `right()`, `fd() instead of `forward()`, `lt() instead of `left()`, and `bk() instead of `backward()`.

Example: Drawing a Square

Python

T.fd(100)

T.rt(90)

T.fd(100)

T.rt(90)

T.fd(100)

T.rt(90)

Fd(100)

In this code, the turtle first moves forward by 100 pixels, then turns right by 90 degrees, moves forward again, and so on, until a square is formed.

By using the forward, backward, left, and right movement commands, you can create various shapes and designs with the Python Turtle library. You can also customize the turtle's appearance, such as its color, size, and speed, to make your drawings more interesting.

Turtle's pen control

Turtle Pen Control

The turtle module in Python provides a range of functions to control the pen's attributes, including its size, speed, colour, and more. Here's a detailed guide on how to use these functions to customise your turtle drawings:

Python Turtle Pen Size

The pen size refers to the thickness of the line drawn by the turtle. To change the pen size, use the `turtle.pensize()` function, providing a positive number as an argument to set the desired thickness. For example:

Python

From turtle import *

Turtle.pensize(10) # Set pen size to 10

Python Turtle Pen Speed

The pen speed determines how fast the turtle moves when drawing. The speed can be set using the `turtle.speed() function, which takes an integer value between 0 and 10 as an argument. For instance:

Python

From turtle import *

Turtle.speed(5) # Set pen speed to 5

Python Turtle Pen Shape

The pen shape can be customised using the `turtle.shape() function. This function takes a string as an argument, specifying the desired shape. The available shapes include "arrow", "turtle", "circle", "square", and "triangle". For example, to set the pen shape to a circle:

Python

From turtle import *

Turtle.shape("circle")

Python Turtle Pen Colour (RGB)

To change the colour of the pen, use the `turtle.pencolor() function. This function accepts a colour string or a tuple of RGB values as arguments. For instance, to set the pen colour to red:

Python

From turtle import *

Turtle.pencolor("red")

You can also specify the colour using RGB values:

Python

From turtle import *

Turtle.pencolor((255, 0, 0)) # Set pen colour to red using RGB

Python Turtle Pen Down and Pen Up

The `turtle.pendown() and `turtle.penup() functions control whether the pen is drawing or not. Calling `turtle.pendown()` will lower the pen and enable drawing, while `turtle.penup()` will lift the pen and stop drawing. For example:

Python

From turtle import *

Turtle.pendown() # Lower the pen and start drawing

Turtle.penup() # Lift the pen and stop drawing

Python Turtle Pen Colour

To change the pen colour, use the `turtle.color() function. This function takes either a colour string or a tuple of RGB values as arguments. For example, to set the pen colour to blue:

Python

From turtle import *

Turtle.color("blue")

You can also specify the colour using RGB values:

Python

From turtle import *

Turtle.color((0, 0, 255)) # Set pen colour to blue using RGB

Turtle's event handling

Turtles event handling

Turtle graphics is an implementation of the popular geometric drawing tools introduced in Logo, developed by Wally Feurzeig, Seymour Papert and Cynthia Solomon in 1967.

Imagine a robotic turtle starting at (0, 0) in the x-y plane. After an import turtle, give it the command turtle.forward(15), and it moves (on-screen!) 15 pixels in the direction it is facing, drawing a line as it moves. Give it the command turtle.right(25), and it rotates in-place 25 degrees clockwise.

Turtle can draw intricate shapes using programs that repeat simple moves.

In Python, turtle graphics provides a representation of a physical “turtle” (a little robot with a pen) that draws on a sheet of paper on the floor.

It’s an effective and well-proven way for learners to encounter programming concepts and interaction with software, as it provides instant, visible feedback. It also provides convenient access to graphical output in general.

Turtle drawing was originally created as an educational tool, to be used by teachers in the classroom. For the programmer who needs to produce some graphical output it can be a way to do that without the overhead of introducing more complex or external libraries into their work.

New users should start here. In this tutorial, we’ll explore some of the basics of turtle drawing.

Starting a turtle environment

In a Python shell, import all the objects of the turtle module:

From turtle import *

If you run into a No module named '_tkinter' error, you’ll have to install the Tk interface package on your system.

Turtle's position

Send your turtle back to its starting-point (useful if it has disappeared off-screen):

The home position is at the center of the turtle’s screen. If you ever need to know them, get the turtle’s x-y coordinates with:

And after a while, it will probably help to clear the window so we can start anew:

Making algorithmic patterns

Using loops, it’s possible to build up geometric patterns:

For steps in range(100):

For c in ('blue', 'red', 'green'):

Color(c)

Forward(steps)

Right(30)

Which of course, are limited only by the imagination!

Let’s draw the star shape at the top of this page. We want red lines, filled in with yellow:

Color('red')

Fillcolor('yellow')

Just as up() and down() determine whether lines will be drawn, filling can be turned on and off:

Next we’ll create a loop:

While True: forward(200) left(170) if abs(pos()) < 1: break

Abs(pos()) < 1 is a good way to know when the turtle is back at its home position.

Finally, complete the filling:

Note that filling only actually takes place when you give the end_fill() command.)

Handling key-press events

Import turtle

Turtle.setup(400,500) # Determine the window size

Wn = turtle.Screen() # Get a reference to the window

Wn.title("Handling keypresses!") # Change the window title

Wn.bgcolor("lightgreen") # Set the background color

Tess = turtle.Turtle() # Create our favorite turtle

The next four functions are our "event handlers".

Def h1():

Tess.forward(30)

Def h2():

Tess.left(45)

Def h3():

Tess.right(45)

Def h4():

Wn.bye() # Close down the turtle window

These lines bind keypresses to the handlers we've defined.

Wn.onkey(h1, "Up")

Wn.onkey(h2, "Left")

Wn.onkey(h3, "Right")

Wn.onkey(h4, "q")

Now we need to tell the window to start listening for events,

If any of the keys that we're monitoring is pressed, its

Handler will be called.

Wn.listen()

Turtle.mainloop()

Handling Mouse-click Events

Import turtle

Turtle.setup(400,500)

Wn = turtle.Screen()

Wn.title("How to handle mouse clicks on the window!")

Wn.bgcolor("lightgreen")

Tess = turtle.Turtle()

Tess.color("purple")

Tess.pensize(3)

Tess.shape("circle")

Def h1(x, y):

Tess.goto(x, y)

Wn.onclick(h1) # Wire up a click on the window.

Turtle.mainloop()

Handling Timer Events

Import turtle

Turtle.setup(400,500)

Wn = turtle.Screen()

Wn.title("Using a timer to get events!")wn.bgcolor("lightgreen")

Tess = turtle.Turtle()

Tess.color("purple")

Def h1():

Tess.forward(100)

Tess.left(56)

Wn.ontimer(h1, 600)

H1()

Turtle.mainloop()

Turtle's state

Turtle State

The turtle's state includes its position, direction, and other attributes such as colour, size, and speed.

The turtle's position is its location on the x-y plane, which can be reset to the origin (0,0) using the `home() function. The position can also be changed using the `setpos()`, `setposition()`, or `goto() functions.

The direction the turtle is facing can be changed using the `right()` and `left()` functions, which take an angle as an argument and turn the turtle by that amount. The `seth() function can be used to set the turtle's heading to a specific angle.

The turtle's colour can be changed using the `color()`, `pencolor()`, and `fillcolor()` functions. The `color()` function changes both the pen colour and the fill colour, while `pencolor()` and `fillcolor()` change only the pen colour and fill colour, respectively.

The pen's width can be adjusted using the `width() or `pensize()` functions.

The speed of the turtle can be adjusted using the `speed() function, which takes an integer value from 0 to 10, with 0 being the slowest and 10 being the fastest.

The turtle's shape can be changed using the `shape()` function, which takes a string argument that specifies the desired shape.

The turtle's visibility can be toggled using the `showturtle()` and `hideturtle()` functions.

The turtle's size can be adjusted using the `turtlesize()` or `shapesize()` functions.

The turtle's tilt and shear can be adjusted using the `tilt()` and `shearfactor()` functions, respectively.

The `get_shapepoly()` function returns the current shape polygon as a tuple of coordinate pairs.

The `resizemode()` function can be used to set the resizemode to "auto", "user", or "noresize", which control how the turtle's appearance adapts to changes in pen size.

The `pos()` function returns the turtle's current position as a tuple of x and y coordinates.

In conclusion, the turtle's state encompasses a variety of attributes that can be modified to create different drawings and animations. By adjusting the position, direction, colour, size, speed, shape, and other attributes, users can create diverse and engaging visuals with the Python Turtle library.

Turtle's screen

The Python Turtle library is a pre-installed Python library that enables users to create pictures and shapes by providing them with a virtual canvas. The onscreen pen that is used for drawing is called the turtle. The turtle is like a little robot with a pen that draws on a sheet of paper on the floor. It is an effective and well-proven way for learners to encounter programming concepts and interaction with software, as it provides instant, visible feedback.

To get started with the Python Turtle library, you need to import the library into your Python environment. You can do this by typing the following line of code:

Python

From turtle import *

Once you have imported the library, you can create a separate window (called the screen) to carry out each drawing command. You can create this screen by initializing a variable for it. For example:

Python

S = turtle.getscreen()

You should see a separate window pop up, and the little black triangular shape in the middle of the screen is the turtle.

Now, you can initialize the variable for the turtle itself, which you will then use throughout the program to refer to the turtle:

Python

T = turtle.Turtle()

You can now start programming the turtle to move around the screen and draw different shapes and images. The turtle has certain changeable characteristics, like size, colour, and speed. It always points in a specific direction and will move in that direction unless you tell it otherwise.

• `t.right(90)` or `t.rt(90)`: Turn the turtle right by 90 degrees.
• `t.left(90)` or `t.lt(90)`: Turn the turtle left by 90 degrees.
• `t.forward(100)` or `t.fd(100)`: Move the turtle forward by 100 units.
• `t.backward(100)` or `t.bk(100)`: Move the turtle backward by 100 units.
• `t.goto(x, y)`: Move the turtle to any other area on the screen using coordinates.

You can also change the characteristics of the turtle and the screen, such as the colour, size, speed, and shape. Here are some examples:

• `turtle.bgcolor("blue")`: Change the background colour of the screen to blue.
• `t.shapesize(1, 5, 10)`: Change the size of the onscreen turtle.
• `t.pensize(5)`: Increase or decrease the thickness of the pen.
• `t.pencolor("green")`: Change the colour of the pen (outline).
• `t.fillcolor("red")`: Change the colour of the turtle (fill).
• `t.shape("circle")`: Change the shape of the turtle (options include "turtle", "arrow", "circle", etc.).

You can also add multiple turtles to the screen and clone existing turtles.

The Python Turtle library is a great way to get started with programming in Python, especially for beginners and children. It provides a fun and interactive way to learn and experiment with programming concepts.

Frequently asked questions