Mutable Object Side Effects

Section 9.11 Mutable Object Side Effects

Subsection 9.11.1 Mutable objects can change when passed to functions

When we pass mutable objects, like lists, to functions, the contents of those objects can be changed within the function. This is a side effect, if the object is not returned from the function. Consider the following example, which we have seen before:

When this code runs and we print out mylst, it looks different from what’s in mylst on line 5. Again, in this example, the bison function is right there, so it isn’t hard to figure out why the list changed, but if there were 100 lines of code between the function definition and the function being called, it would be harder to understand and debug.

We can avoid confusing side effects when passing around mutable objects by passing in a copy of the object and then returning the modified copy and reassigning it to the variable. This makes it much more obvious that the function is altering the mutable object. Here is the code above rewritten to do this:

On line 7 in the code above, we use the built-in list() function, which takes a sequence as a parameter and returns a copy of that sequence as a list. Note also that we had to modify the function to return the list. Once these changes are made, the alterations to the list are no longer considered a side effect, as they are made transparent by returning a changed value.

Subsection 9.11.2 Side Effects in Interactive Programs

When we program interactively and use listener functions, we end up modifying global variables and objects and creating side effects. This is because the listener functions that you can register must only have the parameters relevant to the interaction event. Let’s revisit an earlier example:

import turtle
import random

def random_square():
    """ draws a random square with a random small size
        at turtle's current location
         Pre-Condition: Turtle name alex exists """
    side = random.randrange(10, 30) # get random size
    for _ in range(4): #draw a square in location
        alex.forward(side)
        alex.left(90)

def random_location():
    """ Take turtle to a random location on canvas
        Pre-conditions: Assume turtle is named alex, and
        canvas is 400 x 400 """
    x = random.randrange(-200, 200) # get random x location
    y = random.randrange(-200, 200) # get random y location
    alex.penup()
    alex.goto(x,y) # move to location without drawing
    alex.pendown()

def random_colour():
    """ Sets turtle to a random colour """
    alex.color(random.random(), random.random(), random.random())

def key_r():
    """ draw randomly coloured and positioned square """
    random_colour()
    random_location()
    random_square()

def key_q():
    """ close the canvas window """
    wn.bye()

def click(x, y):
    """ go to clicked location, pick random color and draw square """
    alex.penup()
    alex.goto(x, y)
    alex.pendown()
    random_colour()
    random_square()

wn = turtle.Screen()      # Set up the window and its attributes
alex = turtle.Turtle()    # create alex
alex.speed(10)            # make alex draw fast
random_colour()
random_location()
random_square()

wn.onkey(key_r, 'r')    # tell the operating system to execute function 'key_r()' when the 'r' key is pressed on the keyboard
wn.onkey(key_q, 'q')    # tell the operating system to execute function 'key_q()' when the 'q' key is pressed on the keyboard
wn.onclick(click)       # tell the operating system to execute function 'click' when the user clicks the mouse
wn.listen()             # tell the operating system to listen for events on the canvas window

In this interactive programming example, it isn’t possible to pass the turtle object (alex) to the listener functions key_r() or click() because these functions’ parameters are confined to the parameters needed for responding to specific events. The key_r function is registered to execute when the user presses the r key and as a key listener function it takes no parameters. The click function is registered to execute when the user clicks the mouse and as a mouse-click listener function it must take two parameters so the operating system can pass in the information about where the user clicked the mouse (x and y). We can make this code have fewer side-effects by modifying it as shown below.

import turtle
import random

def random_square(tur):
    """ Post-Condition: square with random small size
        is drawn at turtle's current location """
    side = random.randrange(10, 30) # get random size
    for _ in range(4): #draw a square in location
        tur.forward(side)
        tur.left(90)
    return tur

def random_location(tur):
    """ Post-Condition: turtle is moved to a random location on canvas
        Pre-conditions: Assume canvas is 400 x 400 """
    x = random.randrange(-200, 200) # get random x location
    y = random.randrange(-200, 200) # get random y location
    tur.penup()
    tur.goto(x,y) # move to location without drawing
    tur.pendown()
    return tur

def random_colour(tur):
    """ Post-Condition: turtle is a random colour """
    tur.color(random.random(), random.random(), random.random())
    return tur

def key_r():
    """ draw randomly coloured and positioned square """
    global alex
    alex = random_colour(alex)
    alex = random_location(alex)
    alex = random_square(alex)

def key_q():
    """ close the canvas window """
    wn.bye()

def click(x, y):
    """ go to clicked location, pick random color and draw square """
    global alex
    alex.penup()
    alex.goto(x, y)
    alex.pendown()
    alex = random_colour(alex)
    alex = random_square(alex)

wn = turtle.Screen()      # Set up the window and its attributes
alex = turtle.Turtle()    # create alex
alex.speed(10)            # make alex draw fast
alex = random_colour(alex)
alex = random_location(alex)
alex = random_square(alex)

So, in the code above, we specify that we want to access and edit the global turtle variable (alex) in the listener functions key_r() and click(). Inside those functions, we call the other functions, but now we are passing them the turtle, they are modifying the turtle, and returning the turtle back to us. Now the only side-effects are the effects on the canvas (the square that is drawn, and the color and position of the turtle triangle representation). By returning the turtle object to the listener, we make it really clear that the turtle is changed by the random_square(), random_location() and random_colour() functions.

Check your understanding

Checkpoint 9.11.1.

How many turtles are created in this script?

import turtle
import random

def write_msg(tom, msg, x, y):
    tom.penup()
    tom.goto(x,y)
    tom.pendown()
    tom.write(msg)
    return tom

def here(x, y):
    global alex
    alex = write_msg(alex, "You clicked here!", x, y)

wn = turtle.Screen()      # Set up the window and its attributes
alex = turtle.Turtle()    # create alex
alex = write_msg(alex, "Hello!", 0, 0)
wn.onclick(here)
wn.listen()

none
A turtle named Alex is created on line 16
1
Yes, one turtle is created, and then is passed around and modified
2
A turtle is a mutable object, and it is passed around and modified in this program
It depends on how often the end user clicks
A turtle is a mutable object, and it is passed around and modified in this program

Checkpoint 9.11.2.

What is a side effect of the write_msg function?

import turtle
import random

def write_msg(tom, msg, x, y):
    tom.penup()
    tom.goto(x,y)
    tom.pendown()
    tom.write(msg)
    return tom

def here(x, y):
    global alex
    alex = write_msg(alex, "You clicked here!", x, y)

wn = turtle.Screen()      # Set up the window and its attributes
alex = turtle.Turtle()    # create alex
alex = write_msg(alex, "Hello!", 0, 0)
wn.onclick(here)
wn.listen()

There is no side effect, because the turtle is returned
Changes on the canvas are side effects.
The turtle’s internally stored coordinated are different
Because the turtle is a mutable object, and it is returned from the functions, changes to it are not considered side effects
A msg has been written on the canvas, and the turtle icon is in a different place
Yes changes to what the user sees on the canvas are side effects.
The turtle alex has been modified
Because the turtle is a mutable object, and it is returned from the functions, changes to it are not considered side effects

You have attempted of activities on this page.

Prev Top Next