Mutation, Aliasing, Cloning

Aliasing is tricky, and Python tutor is your friend.

Lists in memory:

lists are mutable
behave differently than immutable types
is an object in memory
variable name points to object
any variable pointing to that object is affected (upon a mutation of the object)
Side effects are the effects of an operation on variables that are not necessarily named in the operation.

An analogy

Attributes of a person: cricketer, fit
He is known by many names
all nicknames point to the same person
- add new attribute to one nickname
```
VIRAT: cricketer, fit, famous
```
- ... all his nicknames refer to old attributes and all new ones
```
Cheeku: cricketer, fit, famous
King Kohli: cricketer, fit, famous
```
  Virat, Cheeku, and King Kohli are aliases for the same person.

Aliases

a = 1
b = a  #b and a are associated with separate objects
a = 2
print(a)
print(b)

warm = ['red', 'yellow', 'orange']
hot = warm #hot and warm are associated with the same list object
hot.append('pink')
print(hot)
print(warm)

The program prints:

2
1
['red', 'yellow', 'orange', 'pink']
['red', 'yellow', 'orange', 'pink']

Show the global scope and how the variables warm and hot are associated with the same list object, i.e., warm and hot alias, i.e., changing one changes the other!

Cloning a list

create a new list and copy every element using
```
chill = cool[:]
```

This is not the only way to create a new list, there are several other ways, as shown below. In the way above, we simply slice the list with the default begin and end values of 0 and len(cool) respectively.

chill = cool + []
chill = cool[0:len(cool)]
chill = cool[0:1] + cool[1:len(cool)]
...

In all the expressions above, the RHS of the assignment simply creates a new list (leaving the original list intact), and then performs the assignment.

Examples:

cool = ['blue', 'green', 'grey']
chill = cool[:]
chill.append('black')
print(chill)
print(cool)

The program prints:

['blue', 'green', 'grey', 'black']
['blue', 'green', 'grey']

Show the global scope and how the variables cool and chill are associated with different list objects.

Sorting Lists

calling sort() mutates the list, returns nothing.
calling sorted() does not mutate the list, must assign result to a variable.

warm = ['red', 'yellow', 'orange']
sortedwarm = warm.sort()
print(warm)
print(sortedwarm)

cool = ['grey', 'green', 'blue']
sortedcool = sorted(cool)
print(cool)
print(sortedcool)

The program prints:

['orange', 'red', 'yellow']
None
['grey', 'green', 'blue']
['blue', 'green', 'grey']

Show the global scope with variables and their associations.

Lists of lists of lists of ...

can have nested lists
side effects still possible after mutation

warm = ['yellow', 'orange']
hot = ['red']
brightcolors = [warm]
brightcolors.append(hot)
print(brightcolors)
hot.append('pink')
print(hot)
print(brightcolors)

The program prints:

[['yellow', 'orange'], ['red']]
['red', 'pink']
[['yellow', 'orange'], ['red', 'pink']]

Show the global scope with variables and their associations. The brightcolors has pointers to the objects that are also pointed-to by warm and hot.

Mutation and Iteration. Try this in Python tutor.

avoid mutating a list as you are iterating over it
```
def remove_dups(L1, L2):
  for e in L1:
    if e in L2:
      L1.remove(e)

L1 = [1, 2, 3, 4]
L2 = [1, 2, 5, 6]
remove_dups(L1, L2)
```
- L1 is [2,3,4], not [3,4]. Why?
  - Python uses an internal counter to keep track of the current index in the list at which it is in the loop.
  - Mutating changes the list length but Python does not update the counter.
  - And so: loop never sees element 2.
Instead, clone the list first, and then iterate on the cloned copy while mutating the original copy:
```
def remove_dups(L1, L2):
  L1_copy = L1[:]
  for e in L1_copy:
    if e in L2:
      L1.remove(e)
```
Notice that L1_copy = L1 does not clone, need L1_copy = L1[:].