Reference semantics,

variables and names

Understanding Reference Semantics
 Assignment manipulates references
—x = y does not make a copy of the object y references
—x = y makes x reference the object y references
 Very useful; but beware!, e.g.
>>> a = [1, 2, 3] # a now references the list [1, 2, 3]
>>> b = a # b now references what a references
>>> a.append(4) # this changes the list a
references
>>> print b # if we print what b references,
[1, 2, 3, 4] # SURPRISE! It has changed…
 Why?
Understanding Reference Semantics

 There’s a lot going on with x = 3

 An integer 3 is created and stored in memory
 A name x is created
 An reference to the memory location storing
the 3 is then assigned to the name x
 So: When we say that the value of x is 3
 we mean that x now refers to the integer 3
Name: x Type: Integer
Ref: <address1> Data: 3

name list memory

Understanding Reference Semantics
 The data 3 we created is of type integer –
objects are typed, variables are not
 In Python, the datatypes integer, float, and
string (and tuple) are “immutable”
 This doesn’t mean we can’t change the value
of x, i.e. change what x refers to …
 For example, we could increment x:
>>> x = 3
>>> x = x + 1
>>> print x
4
 Understanding Reference Semantics
When we increment x, then what happens is:
1. The reference of name x is looked up.
2. The value at that reference is retrieved.

Type: Integer
Name: x Data: 3
Ref: <address1>

>>> x = x + 1
 Understanding Reference Semantics
When we increment x, then what happening is:
1. The reference of name x is looked up.
2. The value at that reference is retrieved.
3. The 3+1 calculation occurs, producing a new
data element 4 which is assigned to a fresh
memory location with a new reference

Type: Integer
Name: x Data: 3
Ref: <address1>
Type: Integer
Data: 4

>>> x = x + 1
 Understanding Reference Semantics
When we increment x, then what happening is:
1. The reference of name x is looked up.
2. The value at that reference is retrieved.
3. The 3+1 calculation occurs, producing a new
data element 4 which is assigned to a fresh
memory location with a new reference
4. The name x is changed to point to new ref

Type: Integer
Name: x Data: 3
Ref: <address1>
Type: Integer
Data: 4

>>> x = x + 1
 Assignment
So, for simple built-in datatypes (integers, floats,
strings) assignment behaves as expected
>>> x = 3 # Creates 3, name x refers to 3

>>> y = x # Creates name y, refers to 3

>>> y = 4 # Creates ref for 4. Changes y
>>> print x # No effect on x, still ref 3
3
 Assignment
So, for simple built-in datatypes (integers, floats,
strings) assignment behaves as expected
>>> x = 3 # Creates 3, name x refers to 3

>>> y = x # Creates name y, refers to 3

>>> y = 4 # Creates ref for 4. Changes y
>>> print x # No effect on x, still ref 3
3
Name: x
Ref: <address1> Type: Integer
Data: 3
 Assignment
So, for simple built-in datatypes (integers, floats,
strings) assignment behaves as expected
>>> x = 3 # Creates 3, name x refers to 3

>>> y = x # Creates name y, refers to 3

>>> y = 4 # Creates ref for 4. Changes y
>>> print x # No effect on x, still ref 3
3
Name: x
Ref: <address1> Type: Integer
Data: 3
Name: y
Ref: <address2>
 Assignment
So, for simple built-in datatypes (integers, floats,
strings) assignment behaves as expected
>>> x = 3 # Creates 3, name x refers to 3

>>> y = x # Creates name y, refers to 3

>>> y = 4 # Creates ref for 4. Changes y
>>> print x # No effect on x, still ref 3
3
Name: x
Ref: <address1> Type: Integer
Data: 3
Name: y
Type: Integer
Ref: <address2>
Data: 4
 Assignment
So, for simple built-in datatypes (integers, floats,
strings) assignment behaves as expected
>>> x = 3 # Creates 3, name x refers to 3

>>> y = x # Creates name y, refers to 3

>>> y = 4 # Creates ref for 4. Changes y
>>> print x # No effect on x, still ref 3
3
Name: x
Ref: <address1> Type: Integer
Data: 3
Name: y
Type: Integer
Ref: <address2>
Data: 4
 Assignment
So, for simple built-in datatypes (integers, floats,
strings) assignment behaves as expected
>>> x = 3 # Creates 3, name x refers to 3

>>> y = x # Creates name y, refers to 3

>>> y = 4 # Creates ref for 4. Changes y
>>> print x # No effect on x, still ref 3
3
Name: x
Ref: <address1> Type: Integer
Data: 3
Name: y
Type: Integer
Ref: <address2>
Data: 4
 Assignment
So, for simple built-in datatypes (integers, floats,
strings) assignment behaves as expected
>>> x = 3 # Creates 3, name x refers to 3

>>> y = x # Creates name y, refers to 3

>>> y = 4 # Creates ref for 4. Changes y
>>> print x # No effect on x, still ref 3
3
Name: x
Ref: <address1> Type: Integer
Data: 3
Name: y
Type: Integer
Ref: <address2>
Data: 4
Assignment & mutable objects
For other data types (lists, dictionaries, user-defined
types), assignment works differently
• These datatypes are “mutable”
• Change occur in place
• We don’t copy them into a new memory address each time
• If we type y=x and then modify y, both x and y are changed

>>> x = 3 x = some mutable object

>>> y = x y = x
immutable
>>> y = 4 mutable
make a change to y
>>> print x look at x
3 x will be changed as well
Why? Changing a Shared List

a = [1, 2, 3] a 1 2 3

a
b=a 1 2 3
b

a
a.append(4) 1 2 3 4
b
 Surprising example surprising no more

So now, here’s our code:

>>> a = [1, 2, 3] # a now references the list [1,

2, 3]
>>> b = a # b now references what a
references
>>> a.append(4) # this changes the list a
references
>>> print b # if we print what b
references,
[1, 2, 3, 4] # SURPRISE! It has
changed…