Lecture 9 - Lambda Functions, Tuples, and Lists Flashcards
Explain what is the output from the code below:
[IN]: L = [1,2,3] [IN]: L.append(L) [IN]: print(L is L[-1])
[OUT]: True
-
L = [1,2,3]- First, a listLis created containing the elements 1, 2, and 3. -
L.append(L)- The listLis appended to itself. This creates a recursive data structure where the list contains a reference to itself as its last element. After this line,Lbecomes[1, 2, 3, [...]]where[...]is a reference to the list itself. -
print(L is L[-1])- This line checks ifLandL[-1](the last element ofL) are the same object using theisoperator. SinceL[-1]is a reference toLitself (due to the previous append operation), this comparison returnsTrue.
Explain what is the output from the code below:
[IN]: L1 = [[]]*2
[IN]: L2 = [[], []]
[IN]: for i in range(len(L1)):
[IN]: L1[i].append(i)
[IN]: L2[i].append(i)
[IN]: print('L1 =', L1, 'but', 'L2 =', L2)
[OUT]: L1 = [[0, 1], [0, 1]] but L2 = [[0], [1]]
Because the first assignment statement creates a list with two elements, each of which is the same object, whereas the second assignment statement creates a list with two different objects, each of which is initially equal to an empty list.
Explain what is aliasing in Python
Aliasing is when two or more variables (names) refer to the same object.
Explain how to create a lamba function that tells if a number is even or not. Moreover, explain how to use it in the REPL.
lambda x: x%2 == 0
This will return True if x is even, or False otherwise. To use it, we can use the code below:
[IN]: (lambda x: x%2 == 0)(8)[OUT]: True
Explain how a lamba function works
lamba parameters : expression
completar
How can a tuple be used to swap variables with less lines of code?
[IN]: x = 1 [IN]: y = 2 [IN]: temp = x [IN]: x = y [IN]: y = temp
[IN]: x = 1 [IN]: y = 2 [IN]: (x, y) = (y, x)
Right-hand side of line 3 is evaluated first and then its values are bound/assigned to x, y
Explain how can we return multiple values from a function? Give an example.
Use a tuple
A function can only return one output so we can define it to return a single tuple that contains multiple values within it.
def quotient_and_reminder(x, y):
q = x // y
r = x % y
return (q, r)
How to create a function that takes an undefined number of formal arguments?
Use *args when defining the function
def mean(*args):
"""
Assumes at least one argument and all arguments are numbers.
Returns the mean of the arguments.
"""
tot = 0
for a in args:
tot += a
return tot/len(args)
Explain how can we test for object equality
But objects of
immutable types cannot be modified after they are created. On the
other hand, objects of mutable types can be modified after they are
created
Explain what would be the output from running the script below.
def append_val(val, list_1 = []):
list_1.append(val)
print(list_1)
append_val(3)
append_val(4)
[OUT]: 3 [OUT]: = [3, 4]
This happens because, at function definition
time, a new object of type list is created, with an initial value of the empty list. Each time append_val is invoked without supplying a value for the formal parameter list_1, the object created at function definition is bound to list_1, mutated, and then printed. So, the second call to append_val mutates and then prints a list that was already mutated by the first call to that function.
Explain what would be the output from running the script below.
def remove_dups(L1, L2):
"""Assumes that L1 and L2 are lists.
Removes any element from L1 that also occurs in L2
"""
for e1 in L1:
if e1 in L2:
L1.remove(e1)
L1 = [1,2,3,4]
L2 = [1,2,5,6]
remove_dups(L1, L2)
print('L1 =', L1)
[OUT]: L1 = [2, 3, 4]
During a for loop, Python keeps track of where it is in the list using an internal counter that is incremented at the end of each iteration. When the value of the counter reaches the current length of the list, the loop terminates.
In this case, the hidden counter starts out at 0, discovers that L1[0] is in L2, and removes it—reducing the length of L1 to 3. The counter is then incremented to 1, and the code proceeds to check if the value of L1[1] is in L2. Notice that this is not the original value of L1[1] (i.e., 2), but rather the current value of L1[1] (i.e., 3). Effectively, this means 2 in L1 was skipped and will not be removed.
Since 3 and 4 are not in L2, no more elements are removed from L1.
Does the second line from script below creates a copy of L1?
[IN]: L1 = [1, 2, 3, 4] [IN]: L1_1 = L1
No, it only binds a new name L1_1 to the same list object [1, 2, 3, 4] to which L1 is already binded.
Note that this is aliasing.
Explain what is the output from running the script below. What kind of copy is created by line 3?
[IN]: L = [2]
[IN]: L1 = [L]
[IN]: L2 = L1.copy()
[IN]: L.append(3)
[IN]: print(f'L1 = {L1}, L2 = {L2}')
[OUT]: L1 = [[2, 3]], L2 = [[2, 3]]
It produces a shallow copy from L1, meaning it creates a list and puts the same objects from L1 in this copy.
Effectively, if I mutate L1, then this will be reflected in L2.
L2 = L1.copy() or L2 = L1[:] produce the same effect in terms of copying L1.
Explain how can I produce a deep copy of L1 in line 3 and bind it to L2. Also, explain how this kind of copy is different from a shallow copy.
[IN]: L = [2]
[IN]: L1 = [L]
[IN]: L2 =\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_
[IN]: L.append(3)
[IN]: print(f'L1 = {L1}, L2 = {L2}')
[IN] import copy [IN]: L2 = copy.deepcopy(L1)
A deep copy creates a new list L2 and put copies of objects from L1 into it. This meas that if I mutate L1, then change will not be reflected into L2.
[OUT]: L1 = [[2, 3]], L2 = [[2]]
Explain the output from the script below
[IN]: L1 = [2] [IN]: L2 = [L1, L1] [IN]: L3 = copy.deepcopy(L2) [IN]: L3[0].append(3) [IN]: print(L3)
[OUT]: [[2, 3], [2, 3]]
copy.deepcopy makes one copy of L1
and uses it both times L1 occurs in L2
Explain the output from the script below
[IN]: a = [[] for _ in range(10)] [IN]: a
[OUT]: [[], [], [], [], [], [], [], [], [], []]
It use a list comprehension to generate a list containing 10 distinct (i.e., non-aliased) empty lists
Explain what is a list comprehension
[ <expression> for item in iterable <if optional_condition> ]
continuar…
