import turtle

dot_size = 10

def dot_at (x , y) :
    turtle.goto (x , y)
    turtle.dot (dot_size)

We can give the dot an initial location:

dot_x  =  0
dot_y  =  0

And write a function to draw the dot at the given location:

def draw_dot () :
    dot_at (dot_x , dot_y)

Turtle will call the event handler whenever the specified event occurs.

Let’s try to add an event handler to move the dot.

def move_right () :     #  a function to move the dot to the right
    dot_x += 10

def right_event () :    #  an event handler function
    move_right ()
    turtle.clear ()     #  erase the old scene
    draw_dot ()
    turtle.update ()    #  paint the new scene

def run_dot () :
    turtle.tracer (0 , 0)      #  don't render to screen unless instructed 
    turtle.hideturtle ()       #  don't show the turtle icon
    turtle.penup ()            #  default turtle state is not drawing
    turtle.onkeypress (right_event , 'Right')    #  register an event handler
    turtle.listen ()                             #  activate event handlers

This won’t work because dot_x is a global variable, so we can’t reassign it from within a function (without some trickery).

It also won’t work to make dot_x a local variable of the move_right function, because then draw_dot won’t know about it.

But if dot_x were a value of mutable type then the move_right could change its value and draw_dot would be able to see it.

class Point :      #  this is the class header
    pass           #  our new class doesn't do anything yet

We can make a new value, called an object, of this type like this:

my_point = Point ()

Each object has its own private variable table where we can store its state:

# initialize our point:
my_point.x = 0
my_point.y = 0

These private variables are called attributes or fields of the object.

Like dictionaries, objects of a class type are mutable: their state can change over time:

my_point.y += 10
my_point.x
my_point.y

This is a collection of functions that lets us interact with its state in a controlled way.

def set_x (point , x_coord) :
    # signature: Point , int -> NoneType
    point.x = x_coord

def set_y (point , y_coord) :
    # signature: Point , int -> NoneType
    point.y = y_coord

def get_x (point) :
    # signature: Point -> int
    return point.x

def get_y (point) :
    # signature: Point -> int
    return point.y

def move_right (point) :
    # signature: Point -> NoneType
    point.x += 10

Interfaces are useful so that the user doesn’t need to care about how an object’s state is represented internally.

They can also be used to prevent users from setting an object’s state to an invalid value.

Unfortunately, this will not work for the Point type yet.

We can fix this by making the interface functions part of the class:

class Point :
    # note that these function definitions are all inside the class:
    def set_x (point , x_coord) :
        point.x = x_coord
    
    def set_y (point , y_coord) :
        point.y = y_coord
    
    def get_x (point) :
        return point.x
    
    def get_y (point) :
        return point.y
    
    def move_right (point) :
        point.x += 10

Now we can call them in either function or method form:

my_point = Point ()
Point.set_x (my_point , 0)  #  ordinary function syntax
my_point.set_y (0)          #  or using method syntax
my_point.move_right ()

We can make this initialization step automatic by defining a constructor method.

A constructor is a method with the special name “__init__” (underscore, underscore, “init”, underscore, underscore).

Its first argument represents the newly-created object of its class; it can take any number of additional arguments.

The constructor automatically gets called whenever you create a new object of the class.

class Point :
    def __init__ (self , init_x , init_y) :
        # signature: Point , int , int -> NoneType
        self.x = init_x
        self.y = init_y
    
    def get_x (self) :
        return self.x
    
    def get_y (self) :
        return self.y
    
    def move_right (self) :
        self.x += 10

It’s conventional (but totally optional) to name the principal argument of a class method “self” or “this”.