We’ll use a table to represent the variables and values in Python’s memory. For example, after running the code

city = "Moose Factory"
population = 2458
employer = city

this table (with the black border) shows what Python’s memory looks like:
The first variable’s name is city and its value is the string "Moose Factory". The second variable’s name is population and its value is the integer 2458. The third variable’s name is employer and its value is the string "Moose Factory".

Next, we show what a list looks like in memory. For example, take the code fragment

myList = ["Moose Factory", 2458]

This will just create one variable, named myList. A list is created, and the value of myList is set equal to “point” or “refer” to that list. We represent the list using a box, and the values of the list’s entries are shown inside the box next to their corresponding indices. The list is shown in blue.
The arrow shows that myList refers to this new list. The element at index 0 of the list is the string "Moose Factory", and the element at index 1 is the integer 2458. For example, if you print(myList[1]) then Python will output 2458.

Now we add one more line to the previous example, just for illustrative purposes. A baby is born, so we run the code fragment

myList = ["Moose Factory", 2458]
myList[1] = myList[1]+1

Python calculates 2458+1 which equals 2459, and this replaces the value at index 1 of the list. After the update, we have the diagram shown below.
(The 2458 isn’t part of Python’s memory, it is only shown to emphasize the change.)

Now we get back to the main example. The first line was

oldSize = ["letter", 8.5, 11]

and so Python’s memory looks like the diagram below after this line is executed. We created a list of length 3.

In our program, the second line is

newSize = oldSize

and here we actually find the main issue: in the second line, = does not duplicate the list! Instead, it just copied a new reference (arrow) pointing to the same list (box). This is quite different from copying numbers or strings (compare with what happened in slide number 1).As the diagram shows, we have two variables, which both refer to the same list.

Next, when the program reaches the line

newSize[1] = newSize[1]*2.54

Python looks at newSize, looks up the value of its index 1 (8.5) and multiplies it by 2.54, and then replaces the value, as shown. However, since oldSize referred to the same list, a side effect is that we also affected oldSize!
(Again 8.5 isn’t part of Python’s memory, and is shown to emphasize the change.)

The next line is similar,

newSize[2] = newSize[2]*2.54

which affects the other value in the list. After this line executes, Python’s memory looks like the diagram shown below.Now when we print either newSize or oldSize, Python outputs ["letter", 21.59, 27.94].