Creating an Etch A Sketch App Using Python and Turtle

and History of the Etch-a-Sketch Tablet

The Etch-a-Sketch tablet was one of the most interesting toys of the late 1950s. Etch-a-Sketch basically looks like a tablet; the red frame has a screen embedded in it and has two knobs. These knobs control the horizontal and vertical movement of the stylus behind the screen. The product quickly became a huge success, with over a million units sold in the first year. It was one of those inventions that would keep kids busy drawing and enjoying themselves, and at the same time, encourage cognitive development by developing fine motor skills, hand-eye coordination, and spatial awareness through button-controlled drawings. It became so popular that it even appeared in films like this one toy Story.

Understanding the Project

In this article, we'll use the Python Turtle Module to develop our stylized, digital version of Etch-a-Sketch. This is a beginner to intermediate level tutorial, which would require a basic understanding of Python basics like Python functions, loops, etc. By coding this project, we'll learn Python event handling, links and motion, functions and loops, and sequential visual feedback. In addition, we will also understand the concept of instances in object-oriented programming. This is an interesting introduction to the core concept of Python, and a fun way to learn programming with a virtual project. Let's get started!

Python's Turtle Module for Visual Coding

In order to create an Etch-a-Sketch Application, we will need a visual representation of our code. This is where Python's Turtle module comes into play. The turtle module is part of the Python standard library, and allows one to draw on a 2D coordinate system with simple commands. The module also supports keyboard input, behaving like a digital pen and thus making it ideal for Etch-a-Sketch simulation.

The turtle module is based on a robotic turtle, which is given certain commands that it follows and produces drawings accordingly. To use this functionality, we must import the module into our code and use the defined functions, which can be discussed in the official documentation here.

The following are a few lines of code that import the module and use a very useful function to draw on the screen:

import turtle
turtle.forward(100)
turtle.right(90)
turtle.forward(100)
turtle.right(45)
turtle.forward(100)
turtle.exitonclick()

I forward function is used to move the cursor forward and takes distance as an argument, while i right function turns the turtle's head to the right by the given angle as a counter. Additional details of each job can be accessed through the official documentation.

The Turtle module also has object-oriented programming capabilities, which means we can create objects from a given blueprint. I Turtle again Screen class can be used to create object instances to be used in our code. Let's create these:

my_pen= Turtle()
my_pen.width(3)
my_pen.speed(0)
screen = Screen()
screen.title("Etch A Sketch")

See how we created the turtle object and named it my_pen from the Turtle Class which is part of the Python Turtle Module. We also created a screen object, which will allow us to visualize the movement of the pen and customize it according to our needs. We customized the width and speed of the pen, and named the screen.

Defining Movement Functions

The following is to describe the functions of our pen movement. As a virtual Etch-a-Sketch tablet, with 2 knobs, one for moving up and down, and the second for moving horizontally to the right, we will define a total of 4 functions:

1. Go Forward: This will move the pen up, similar to up on the original tablet.
2. Go Back: This will move the pen down, similar to moving down on the original tablet.
3. Rotate Left: This will move the pen to the left by a certain angle.
4. Rotate Right: This will move the pen to the right by a certain angle.

Let's write the above as functions:

def move_forwards():
    my_pen.forward(50)

def move_backwards():
    my_pen.backward(50)

def turn_left():
    new_heading = my_pen.heading() + 10
    my_pen.setheading(new_heading)

def turn_rigth():
    new_heading = my_pen.heading() - 10
    my_pen.setheading(new_heading)

For the first two tasks, we directly used the forward and backward turtle functions. In horizontal motion tasks, turn_left again turn_rightwe defined a new variable new_heading which is basically the angle the pen will turn. I new_heading it takes the pen tip which is the current angle and adds 10 degrees when you turn left and subtracts 10 degrees when you turn right. This angle will be saved as new_heading which will serve as an argument to the set-title function that sets the pen orientation at the angle given as an argument.

We will also define a function that will clear the screen. This activity uses a turtle clear function that removes the drawing of a turtle from the screen without affecting the shape and location of the turtle. It will also return the location of the pen home, using the penup, home again pendown activities:

def clear_screen():
    my_pen.clear()
    my_pen.penup()
    my_pen.home()
    my_pen.pendown()

Screen Listening

One of the capabilities of the turtle module is that it allows for screen listening events. In a program, an event listener is a concept that receives and responds to user actions. In our case, the user action will be through the keyboard, using the WASD keys for pen movement. We will use this functionality in our code. This can be done by using the listen again onkey method of the screen object. I listen method is used to collect important events, and onkey method defines a function to be called based on a particular button pressed.

screen.listen()
screen.onkey(move_forwards, "w")
screen.onkey(move_backwards, "s")
screen.onkey(turn_left, "a")
screen.onkey(turn_rigth, "d")
screen.onkey(clear_screen, "c")

Finally, since we want to save the screen, we will use the exitonclick screen method that can save the screen until we click on it.

screen.exitonclick()

Etching & Sketching!

Now that our code is complete, we will run the program. The screen will appear in front of us and it will stay like that until we click anywhere on it.

We will use the keys “W”, “A”, “S” and “D” to create a drawing and “C” to clear the screen. Let's draw a circle on the keyboard!

You can also draw a circle by simply moving forward with “W” and turning the left key “A” twice, and keep doing that until the pen reaches its starting point. And we can practice drawing shapes and understanding geometry every time we play with this program.

Project Development

Now that our basic program is done, we can add many other features that can customize and improve our creation, such as:

• Adding keys and corresponding functions for diagonal movement
• To change the color of the pen
• Saving drawings and exporting the canvas as an image

The conclusion

We successfully used our basic knowledge of Python and the Turtle module to create a digital Etch-a-Sketch program. This is a fun way to learn to program and understand links, as everything is shown visually. It also makes it easy to identify any mistakes someone makes in the code and correct the error in a timely manner. Although simple in its code, this type of program forms the basis of complex graphical programs and front-end software, so a basic understanding of the graphical interface is essential to understand the basics of digital graphics.