Lecture 11 - Aliasing, Cloning Flashcards
Explain how to create a copy of the list L below.L = [1, 2, 3, 4]
Retrieve all elements from L using [:] and bind them to a new list object called Lcopy.L_copy = L[:]
Explain what is the output from lines 3 and 5.
~~~
1 [IN]: L = [1, 2, 3, 4]
2 [IN]: el = L.remove(3)
3 [IN]: print(L)
4 [OUT]: ???
5 [IN]: print(el)
6 [OUT]: ???
~~~
The .remove( ) method does not return any value so el will be None.
4 [OUT]: [1, 2, 4] 6 [OUT]: None
Explain what is the output from code below
~~~
1 [IN]: L = [1, 2, 3, 4]
2 [IN]: el = del(L[1])
3 [IN]: print(L)
4 [OUT]: ???
5 [IN]: print(el)
6 [OUT]: ???
~~~
Line 2 will throw a Syntax Error since the del( ) function does not return any value. Therefore, nothing will be printed in Line 6.
Line 4 will print [1, 3, 4]
Explain what is the output from lines 3 and 5.
~~~
1 [IN]: L = [1, 2, 3, 4]
2 [IN]: el = L.pop()
3 [IN]: print(L)
4 [OUT]: ???
5 [IN]: print(el)
6 [OUT]: ???
~~~
4 [OUT]: [1, 2, 3] 6 [OUT]: 4
Explain what will be printed to the console after line 14
~~~
1 def remove_all(L, e):
2 “””
3 L is a list
4 Mutates L to remove all elements
5 in L that are equal to e
6 Returns None.
7 “””
8 for el in L:
9 if el == e:
10 L.remove(e)
11
12 [IN]: L2 = [1, 2, 2, 2]
13 [IN]: remove_all(L2, 2)
14 [IN]: print(L2)
~~~
[OUT]: [1, 2]
1st Iteration: L is still [1, 2, 2, 2]
2nd Iteration: the .remove( ) method removes the first 2, mutating L and reducing its length by 1. However, Python does not take this into consideration on the counter for the for loop. The output from the second iteration is [1, 2, 2]
3rd Iteration: The counter for the for loop is currently at 2, so effectively, Python will skip the 2 in the middle and will remove the last 2. L is mutated to [1, 2] and the counter, now at 3, will overshoot the current of L, which is 2, so the final output is [1, 2].
The point here is that we are looping over L while mutating it and this sometimes leads to unexpected behaviours if we are not careful.
When the remove_dups( ) function is called with L1, L2 as arguments, it returns [20, 30, 40] instead of the expected result of [30, 40]. Explain why this happens and how to fix it.
def remove_dups(L1, L2):
for e in L1:
if e in L2:
L1.remove(e)
L1 = [10, 20, 30, 40]
L2 = [10, 20, 50, 60]
remove_dups(L1, L2)
print(L1)
This happens because we are iterating over a list that is being mutating at the same time. Elemens are being removed from the list, altering its length, but the internal counter of the for loop does not care about these changes.
One option is to create a copy from the original list and iterate over it instead of the actual list. Therefore, we will be iterating over an object that remains constant through the entire loop.
def remove_dups(L1, L2):
L1_copy = L1[:] #copy from L1
for e in L1_copy: #iterates over copy, not L1
if e in L2:
L1.remove(e)
What will be the results from calling both function, A & B, with the arguments ([1, 2, 3, 4], [1, 2, 5, 6]). Also, explain why these function produce these results.
def remove_dups_A(L1, L2):
L1_copy = L1
for e in L1:
if e in L2:
L1.remove(e)
def remove_dups_B(L1, L2):
L1_copy = L1[:]
for e in L1_copy:
if e in L2:
L1.remove(e)
remove_dups_A: [2, 3, 4]remove_dups_B: [3, 4]
In ` remove_dups_A, L1_copy = L does not actually create a copy of L, it just creates an **alias**. Therefore, the for loop will iterate over L while mutating it at the same time, through the .remove( )` method. Once we remove an element, all elements from L are shifted over to the left by 1 position, however the internal counter for the loop will move forwards regardless of this change, effectively meaning we will skip an element. If we remove another element, the shift and the skip will happen again.
In remove_dups_B, L1_copy = L[:] creates a copy of L, and we will iterate over this copy, which remains constant through the whole loop. Therefore, we avoid the issue found with ` remove_dups_A`.
remove_dups_a( ) function
Explain what kind of copy from old_list is new_list. Moreover, if I append [7, 8] to old_list, will I find it on new_list as well?
new_list is a shallow copy, meaning it copies the object type and length of old_list, but creates pointers to its elements since these are mutatable themselves.
old_list.append([7, 8]) will add an element to the end of old_list, but it will not change the other elements. As we had first created the copy and then added [7,8], this will not be appended to new_list.
Explain what kind of copy from old_list is new_list. Moreover, if I append [7, 8] to old_list, will I find it also on new_list as well?
