Lecture 10 - Lists, Mutability Flashcards
Explain what is the difference of using .sort( ) and sorted( ) with a list object
.sort( ) is a method that mutates the original list object
[IN]: L1 = [2, 7, 3, 8, 9, 1, 4] [IN]: L1.sort() [IN]: print(L1) [OUT]: [1, 2, 3, 4, 7, 8, 9]
sorted( ) is a function that does not mutate the original list object
~~~
[IN]: L2 = [2, 7, 3, 8, 9, 1, 4]
[IN]: L3 = sorted(L2)
[IN]: print(L3)
[OUT]: [1, 2, 3, 4, 7, 8, 9]
[IN]: print(L2)
[OUT]: [2, 7, 3, 8, 9, 1, 4]
~~~
Explain the difference between mutable and immutable objects, and give an example for each one.
Mutable objects, like lists, can be altered after they have been created.
Alternatively, immutable objects, like tuples, str, int, cannot be altered once they have been created. If we want to change these, we need to create new objects are re-bind the variables (names) to to it.
Explain how to combine the elements from the list object new_ls into a single string, with each element being separated from the next one by a space.
[IN]: new_ls = ['A', 'stream', 'of', 'bright', 'points', 'flowing', 'from', 'left', 'to', 'right', 'and', 'combining', 'to', 'transform', 'into', 'a', 'solid', 'object']
Use the .join() method
[IN] phrase = " ".join(new_ls) [IN] print(phrase) [OUT]: 'A stream of bright points flowing from left to right and combining to transform into a solid object'
Explain why we would not need a return statement for the function below that is intended to mutate a list by raising each element to the power of two.
~~~
def square_list(L):
for i in range(len(L)):
L[i] = L[i] ** 2
~~~
As the purpose of the function is to mutate the original list object, there is no need to bind the mutated list (function output) to a new object, hence we do not need the return.
We can just let the function mutate its elements, by means of a for loop and value assignment, and then print or call the list object to check its effect.
If we have data with a large number of composing elements, e.g. sales records from an online shop, then what would be the advantage of storing this in a mutable (e.g. list) vs immutable (e.g. tuple) object?
Suppose we want to change one element from this large dataset.
If we would use an immutable object, then we would need to copy the data to a new object since these kind of object cannot be altered after creation.
If we would use a mutable object, then we can simply change the records need by indexing/slicing, without having to create copies from the dataset.
Explain what is the output from code below.
~~~
L = [1,2,3,4]
i = 0
for e in L:
L.append(i)
i += 1
print(L)
~~~
It results in an infite loop. Each iteration e moves to the next element from L, but list object L also becomes one element larger. Effectively, e will never reach the end of L.
The key point here is that we are iterating over a mutating object and this needs attention as it may result in undesired behaviour.
Explain what will be the output from the last line of code. Will it be [1, 2, 3, 4, 5, 6] or [1, 2, 3, 7, 4, 5, 6] ?
~~~
[IN]: L1 = [1, 2, 3]
[IN]: L2 = [4, 5, 6]
[IN]: L3 = L1 + L2; print(L3)
[OUT]: [1, 2, 3, 4, 5, 6]
[IN]: L1.append(7);print(L1)
[OUT]: [1, 2, 3, 7]
[IN]: print(L3)
~~~
[OUT]: [1, 2, 3, 4, 5, 6]
Concatenating (+ operator) list objects uses copies from the lists being concatenated instead of references.
That is why after we mutate L1, L3 does not suffer any side effect.
Explain the output and execution flow of code below.
~~~
L = [1, 2, 3, 4]
for e in L:
L = L + L
print(L)
~~~
OUT: [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]
Think about the stack frame for variables e and L.
L mutates over the loop, but e keeps its binding to the original [1, 2, 3, 4] object hence it does not result in an infinite loop.
Concatante uses copies instead of references.
2nd iteration through the loop (see image below)
Explain what will be the three outputs below. Think about object equality and mutability.
~~~
[IN]: L = [4,5,6];print(id(L))
[OUT]: ?
[IN]: L.append(8);print(id(L))
[OUT]: ?
[IN]: L.clear();print(id(L))
[OUT]: ?
~~~
[OUT]: 1888763712960 [OUT]: 1888763712960 [OUT]: 1888763712960
Outputs (ids) are the same since we are mutating over the same list object.
Explain what will be the three outputs below. Think about object equality and mutability.
~~~
[IN]: L = [4,5,6];print(id(L))
[OUT]: ?
[IN]: L.append(8);print(id(L))
[OUT]: ?
[IN]: L = [];print(id(L))
[OUT]: ?
~~~
[OUT]: 1888763685312 [OUT]: 1888763685312 [OUT]: 1888763922624
The first two ids are the same since we are mutating the same list object.
The last id will be different since we created a new empy list object.
