9.16. Multiple Choice Questions¶
- [ [ ], 3.14, False]
- Incorrect! This slice starts at index 4 and goes up to and includes the last item.
- ["cat", [56, 57, "dog"]]
- Correct! The word "cat" is at index 2 and [56, 57, "dog"] is what you get when index 4 is exclusive.
- [ [56, 57, "dog"], [ ], 3.14, False]
- Incorrect! Remember that index values start at 0!
- [27, "cat"]
- Incorrect! This slice starts at index 4 and goes up to and includes the last item.
Q-1: What is returned by the following function?
def slice_exercise():
alist = [3, 67, "cat", [56, 57, "dog"], [ ], 3.14, False]
print(alist[2:4])
- 4
- Incorrect! The built in function, len, returns the actual number of items in the list, not the maximum index value.
- 5
- Correct! There are 5 items in this list.
- False
- Incorrect! The built in function, len, returns the actual number of items in the list.
- 3.14
- Incorrect! The built in function, len, returns the actual number of items in the list.
Q-2: What is returned by the following function?
def len_of_list():
alist = [3, 67, "cat", 3.14, False]
return len(alist)
- Error, you cannot use the upper method on a list.
- Incorrect! alist[2] is the string cat so the upper method is legal
- 2
- Incorrect! 2 is the index. We want the item at that index.
- CAT
- Correct! The string cat is upper cased to become CAT.
- FALSE
- Incorrect! False is at the maximum index, not the second index.
Q-3: What is returned by the following function?
def indexing_and_upper():
alist = [3, 67, "cat", [56, 57, "dog"], [ ], 3.14, False]
return alist[2].upper()
- 56
- Indexes start with 0, not 1.
- c
- Yes, the first character of the string at index 2 is c
- cat
- cat is the item at index 2 but then we index into it further.
- Error, you cannot have two index values unless you are using slicing.
- Using more than one index is fine. You read it from left to right.
Q-4: What is returned by the following function?
def list_within_list():
alist = [3, 67, "cat", [56, 57, "dog"], [ ], 3.14, False]
return alist[2][0]
- [4, 2, 8, 999, 5, 4, 2, 8, 999, 5]
- [alist] * 2 creates a list containing alist repeated 2 times
- [[4, 2, 8, 999, 5], [4, 2, 8, 999, 5]]
- Yes, blist contains two references, both to alist.
- [4, 2, 8, 6, 5]
- print(blist)
- [[4, 2, 8, 999, 5], [4, 2, 8, 6, 5]]
- blist contains two references, both to alist so changes to alist appear both times.
Q-5: What is returned by the following function?
def list_transformation():
alist = [4, 2, 8, 6, 5]
blist = [alist] * 2
alist[3] = 999
return blist
- [4, 2, 8, 6, 5]
- 5 is added to each item before the append is performed.
- [4, 2, 8, 6, 5, 5]
- There are too many items in this list. Only 5 append operations are performed.
- [9, 7, 13, 11, 10]
- Yes, the for loop processes each item of the list. 5 is added before it is appended to blist.
- Error, you cannot concatenate inside an append.
- 5 is added to each item before the append is performed.
Q-6: What is returned by the following function?
def list_transformation():
alist = [4, 2, 8, 6, 5]
blist = [ ]
for item in alist:
blist.append(item+5)
return blist
- .pop()
- pop removes and returns items (default is to remove and return the last item in the list)
- .insert()
- insert will add an item at whatever position is specified.
- .count()
- count returns the number of times something occurs in a list
- .index()
- Yes, index will return the position of the first occurrence of an item.
Q-7: Which method would you use to figure out the position of an item in a list?
- .insert()
- While you can use insert, it is not the best method to use because you need to specify that you want to stick the new item at the end.
- .pop()
- pop removes an item from a list
- .append()
- Yes, though you can use insert to do the same thing, you don't need to provide the position.
- .remove()
- remove gets rid of the first occurrence of any item that it is told. It does not add an item.
Q-8: Which method is best to use when adding an item to the end of a list?
- I.
- This pattern will only count how many items are in the list, not provide the total accumulated value.
- II.
- This would reset the value of s each time the for loop iterated, and so by the end s would be assigned the value of the last item in the list plus the last item in the list.
- III.
- Yes, this will solve the problem.
- none of the above would be appropriate for the problem.
- One of the patterns above is a correct way to solve the problem.
Q-9: Given that we want to accumulate the total sum of a list of numbers, which of the following accumulator patterns would be appropriate?
def find_sum():
nums = [4, 5, 2, 93, 3, 5]
s = 0
for n in nums:
s = s + 1
return s
def find_sum():
nums = [4, 5, 2, 93, 3, 5]
s = 0
for n in nums:
s = n + n
return s
def find_sum():
nums = [4, 5, 2, 93, 3, 5]
s = 0
for n in nums:
s = s + n
return s
- 1.
- How does this solution know that the element of lst is a string and that s should be updated?
- 2.
- What happens to s each time the for loop iterates?
- 3.
- Reread the prompt again, what do we want to accumulate?
- 4.
- Yes, this will solve the problem.
- none of the above would be appropriate for the problem.
- One of the patterns above is a correct way to solve the problem.
Q-10: Given that we want to accumulate the total number of strings in the list, which of the following accumulator patterns would be appropriate?
def num_of_strings():
lst = ['plan', 'answer', 5, 9.29, 'order, items', [4]]
s = 0
for n in lst:
s = s + n
return s
def num_of_strings():
lst = ['plan', 'answer', 5, 9.29, 'order, items', [4]]
for item in lst:
s = 0
if isinstance(item, str):
s = s + 1
return s
def num_of_strings():
lst = ['plan', 'answer', 5, 9.29, 'order, items', [4]]
s = ""
for n in lst:
s = s + n
return s
def num_of_strings():
lst = ['plan', 'answer', 5, 9.29, 'order, items', [4]]
s = 0
for item in lst:
if isinstance(item, str):
s = s + 1
- [3, 0, 2, 0, 0]
- The list is modified by the pop.
- [3, 0, 2]
- It will pop 0's except for the last one.
- [3, 2]
- This would be true if it didn't always increment the index.
- [3, 2, 0]
- Since it always increments the index it will miss the last zero.
Q-11: What will the following code print?
def mystery(num_list):
index = 0
while index < len(num_list):
num = num_list[index]
if num == 0:
num_list.pop(index)
index += 1
list1 = [3, 0, 2, 0, 0]
mystery(list1)
print(list1)
- 1
- It adds 1 to the sum and then returns.
- 9
- This would be true if it didn't return until after the loop finished
- 15
- This would be true if it didn't return until after the loop finished and the range incremented by 1 rather than 2
- None
- This would be true if there wasn't a return statement
Q-12: What will the following code print?
def mystery(num_list):
sum = 0
for i in range(0, len(num_list), 2):
num = num_list[i]
sum += num
return sum
list1 = [1, 2, 3, 4, 5]
print(mystery(list1))
- True
- It returns true after checking the first num.
- False
- This would be true if the first number in the list was negative.
- None
- This would be true if there wasn't a return statement.
- It will not compile
- This would be true if there was a syntax error.
Q-13: What will the following code print?
def mystery(num_list):
for num in num_list:
if num < 0:
return False
else:
return True
print(mystery([3, -1, 2]))
- [10, 15, 20]
- It only adds numbers that are greater than 10
- [20, 15]
- This would be true if append added at the front, but it adds at the end
- [15, 20]
- It adds all numbers greater than 10 in order.
- [20, 15, 10]
- This would be true if append added at the front, but it adds at the end and it won't add the 10
Q-14: What will the following code print?
def mystery(num_list):
out = []
for num in num_list:
if num > 10:
out.append(num)
return out
print(mystery([5, 10, 15, 20]))
- [5, 10, 15, 20]
- It adds the numbers in reverse order
- [20, 15, 10, 5]
- This would be true if the end for range was less than 0
- [5, 10, 15]
- It adds the numbers in reverse order
- [20, 15, 10]
- It adds the numbers in reverse order, but stops before the item at index 0.
Q-15: What will the following code print?
def mystery(num_list):
out = []
for i in range(len(num_list) - 1,0,-1):
num = num_list[i]
out.append(num)
return out
print(mystery([5, 10, 15, 20]))