Lists, Stacks, and Queues: 10 practice questions

Question 1 of 10

Which list method adds one item to the end of an existing list?

1. ACall `append(value)` on the list.
2. BCall `extend(value)` on the list.
3. CCall `count(value)` on the list.
4. DCall `insert(0, value)` on the list.

Question 2 of 10

What does `items.pop()` do when `items` is a nonempty list?

1. AIt removes every item and returns `None`.
2. BIt removes and returns the first item.
3. CIt removes and returns the last item.
4. DIt returns the last item without removing it.

Question 3 of 10

What is the effect of `del records` on the variable name `records`?

1. AThe name is deleted, so a later reference is an error until reassignment.
2. BThe final list item is removed and returned.
3. CThe list remains bound to the name but becomes empty.
4. DThe first list item is removed while the name remains bound.

Question 4 of 10

A list must receive each element from another iterable as a separate new item. Which method fits?

1. AUse `remove(iterable)`.
2. BUse `extend(iterable)`.
3. CUse `count(iterable)`.
4. DUse `append(iterable)`.

Question 5 of 10

How does `values.remove(target)` behave when `target` appears more than once?

1. AIt deletes every equal item and returns their former count.
2. BIt deletes the final equal item and leaves earlier matches in place.
3. CIt deletes the first equal item and leaves later matches in place.
4. DIt returns the first matching index without changing the list.

Question 6 of 10

After `result = names.sort()`, which statement describes the documented behavior?

1. A`names` is reversed in place and `result` is the list.
2. B`result` is a sorted copy while `names` is unchanged.
3. C`result` is the removed final item while `names` becomes shorter.
4. D`names` is sorted in place and `result` is `None`.

Question 7 of 10

Which operation removes the item at index 2 without producing that item as a return value?

1. AExecute `values.remove(2)`.
2. BExecute `del values[2]`.
3. CExecute `values.pop(2)`.
4. DExecute `values.index(2)`.

Question 8 of 10

An undo history adds each new action at one end and must retrieve the most recently added action before older ones. Which pair meets both constraints?

1. AAdd with `insert(0, action)` and retrieve with index-free `pop()`.
2. BAdd with `append()` and retrieve with index-free `pop()`.
3. CAdd with `append()` and retrieve with `pop(0)` from the front.
4. DAdd with `extend(action)` and retrieve with `remove(action)`.

Question 9 of 10

A busy service must process arrivals in their original order and frequently add and remove items without shifting the remaining elements. Which design fits?

1. AUse a `collections.deque`, adding and removing with index-free `pop()`.
2. BUse a `collections.deque`, adding with `append()` and removing with `popleft()`.
3. CUse a list, adding with `append()` and removing with `pop(0)`.
4. DUse a list, adding with `insert(0, item)` and removing with `pop()`.

Question 10 of 10

A cleanup must remove positions 2 through 4 from `records`, leave the same name usable, and ignore the removed values. Which statement satisfies all constraints?

1. AExecute `del records` and then refer to `records`.
2. BExecute `del records[2:5]` while retaining the name.
3. CExecute `records.remove(2:5)` and keep using the list.
4. DExecute `records.pop(2:5)` and ignore its result.