Question 1

Slice creates a shallow copy

Accepted Answer

a[:] creates a new list containing the same elements - a shallow copy. Appending to b only modifies b; a is untouched because they are separate objects. The shallow part matters with nested objects: if a element were a list itself, both a and b would share that inner list.

Question 2

append vs extend

Accepted Answer

append adds a single item - even if that item is a list. So a becomes [1, 2, [3, 4]], length 3. extend unpacks an iterable and adds each element individually. b becomes [1, 2, 3, 4], length 4. A common bug is using append when you want to merge two lists.

Question 3

Negative indexing

Accepted Answer

Negative indices count from the end of the list. -1 is the last element, -2 is second-to-last, and so on. nums[-2] is equivalent to nums[len(nums) - 2] = nums[3] = 40. This is a clean way to access tail elements without computing the length yourself.

Question 4

sort() vs sorted()

Accepted Answer

list.sort() sorts the list in place and returns None - a common gotcha is writing 'a = a.sort()' which sets a to None. sorted() accepts any iterable and always returns a new sorted list, leaving the original unchanged. Use sort() when you want to modify the list and don't need the original order; use sorted() when you need both or when working with other iterables like tuples.

Question 5

list.pop() with no argument

Accepted Answer

list.pop() with no argument removes and returns the last element - equivalent to pop(-1). To remove the first element you'd write pop(0), but this is O(n) because all remaining elements shift left. If you need efficient removal from both ends, use collections.deque instead.

Question 6

in operator on a list

Accepted Answer

The 'in' operator on a list checks for exact element membership, not substrings. 'banana' is an element of the list, so it's True. 'ban' is a substring of 'banana' but is not itself an element of the list, so it's False. For substring checking, use 'ban' in 'banana' (checking inside a string), not against the list.

Question 7

Extended unpacking with *

Accepted Answer

The starred variable in unpacking captures everything that doesn't belong to the named positions. 'first' gets 1, 'last' gets 5, and '*middle' captures all remaining elements as a list: [2, 3, 4]. The starred variable is always a list even if it captures 0 or 1 elements.

Question 8

del vs remove()

Accepted Answer

del lst[i] deletes the element at position i - you need to know the index. lst.remove(v) scans left to right and deletes the first element equal to v - you need to know the value. If you want to remove all occurrences of a value, you'd need a loop or a list comprehension like [x for x in lst if x != v].

Question 9

append adds a nested list

Accepted Answer

append treats its argument as a single item, regardless of type. The entire list [4, 5] is inserted as one element, making it the last item. lst[-1] fetches that last element, which is the nested list [4, 5]. If you had used extend([4, 5]) instead, the last element would have been 5 (an integer), not a list.

Question 10

Negative index with assignment

Accepted Answer

Negative indices work for assignment just as they do for reading. -1 refers to the last element, so nums[-1] = 99 replaces 50 with 99. The rest of the list is unchanged. This lets you update the last element without writing nums[len(nums) - 1] or knowing the list's length in advance.

Question 11

sort() returns None

Accepted Answer

list.sort() is an in-place operation that returns None, not the sorted list. Assigning its return value gives you None. The sorting did happen though - nums itself is now [1, 2, 3]. The classic bug is 'nums = nums.sort()' which destroys your reference to the list. Use sorted(nums) if you need to capture the result.

Question 12

pop() return value

Accepted Answer

pop() both removes and returns the element. The last element 4 is captured in val, and stack is left as [1, 2, 3]. This in-place removal with a return value is why lists work naturally as stacks: push with append(), pop with pop(). Both operations are O(1) at the end of a list.

Question 13

Unpacking with star at the front

Accepted Answer

The starred variable can appear at any position - left, middle, or right. Here *rest is on the left, so it captures everything except the final element. 'last' gets 40, and rest is [10, 20, 30]. Like always, the starred result is a list, not a tuple. This pattern is handy for peeling off the last item, just as first, *rest = ... peels off the first.

Question 14

in operator with a nested list

Accepted Answer

The 'in' operator checks whether an item is a direct element of the list, using equality (==). [3, 4] == data[1] is True, so [3, 4] in data is True. But 3 is not a direct element - it lives inside a nested list. To check for membership inside nested structures you'd need to flatten the list or use any(3 in row for row in data).

Question 15

remove() on duplicates

Accepted Answer

remove() finds and deletes the first occurrence of the given value, then stops. The list has 2 at index 1 and at index 3. Only the first one (index 1) is removed, leaving the second 2 still in the list. To remove every occurrence you'd write something like 'while 2 in nums: nums.remove(2)' or use a comprehension.