9.16. Multiple Choice Questions

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])

• [ [ ], 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-2: What is returned by the following function?

def len_of_list():
    alist = [3, 67, "cat", 3.14, False]
    return len(alist)

• 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-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()

• 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-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]

• 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-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, 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-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

• [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-7: Which method would you use to figure out the position of an item in a list?

• .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-8: Which method is best to use when adding an item to the end of 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-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

• 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-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

• 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-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)

• [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-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))

• 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-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]))

• 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-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]))

• [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-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]))

• [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.

You have attempted of activities on this page