Exercises — List methods — append, insert, remove, pop, sort, reverse, count, index

"Return" = the value the expression evaluates to. "After" = the state of the list.

• nums.append(9) → returns ==None==; list becomes [3, 1, 2, 9]. (Adds to the end, mutates in place.)
• nums.sort() → returns ==None==; list becomes [1, 2, 3]. (Reorders in place.)
• nums.pop() → returns ==2== (the last item); list becomes [3, 1]. (Removes and hands it back.)
• nums.count(1) → returns ==1==; list unchanged [3, 1, 2]. (Just asks a question — never mutates.)

Key split: pop, count, index give you a useful value back; append, sort, insert, remove, reverse give back None.

• insert → Adder (puts a new item in).
• reverse → Mover (reorders, adds/removes nothing).
• index → Asker (returns a position, changes nothing).
• remove → Taker (deletes an item by value).

• Step 1 insert(2, 8): index 2 held 5; everything at index $\ge 2$ shifts right one. → [5, 3, 8, 5, 1].
• Step 2 a = nums.pop(0): removes and returns the front item. a = 5; list → [3, 8, 5, 1].
• Step 3 b = nums.pop(): no argument means last item. b = 1; list → [3, 8, 5].
• Step 4 remove(5): searches by value, deletes the first 5. → [3, 8].

Answers: a = 5, b = 1, nums = [3, 8].

• sort() → [1, 2, 4, 4] (ascending).
• reverse() → [4, 4, 2, 1] (flip, does not re-sort).
• index(4) → returns the first position of 4, which is 0.
• count(4) → 2.

Answers: index(4) = 0, count(4) = 2.

remove takes a value, not an index. There is no value 0 inside [5, 6, 7], so Python raises a ==ValueError== on the box.remove(0) line. The trap: someone reading it thinks "remove index 0." That is pop(0), which would return 5. See Exceptions — ValueError and IndexError.

• lst.sort() mutates lst to [3, 6, 8] and returns None.
• result = None, so print(result) prints None.
• print(lst) prints [3, 6, 8].

The data is not lost — it was sorted in place; only the return value is None. This is the assignment bug from L1, seen live.

sort() orders items by repeatedly asking "is x < y?". Python knows how to compare str with str ('a' < 'b') and int with int, but not int with str. So [1, 'a'].sort() raises a ==TypeError==, while ['b', 'a'].sort() → ['a', 'b']. Keep list items to one comparable type. See Mutability vs Immutability in Python for why lists let you do all this in place.

One clean route:

raw = [4, 2, 4, 1, 2, 4]
raw.sort()                 # [1, 2, 2, 4, 4, 4]
out = []
for x in raw:
    if out.count(x) == 0:  # not seen yet
        out.append(x)      # out builds up distinct values ascending
out.reverse()              # descending

• After the loop, out = [1, 2, 4] (each value appended once, ascending because raw was sorted).
• reverse() → [4, 2, 1].

Final: out = [4, 2, 1]. Here count is the Asker guarding against duplicates, append the Adder, reverse the Mover — three families cooperating.

We must not mutate q, so we make a copy with the function sorted:

s = sorted(q)        # ['a', 'a', 'b', 'b', 'c']  (q untouched)
first = s[0]         # 'a'  — alphabetically first
pos = q.index(first) # where 'a' first appears in original q

• s = ['a', 'a', 'b', 'b', 'c'], and q is still ['b', 'a', 'c', 'a', 'b'].
• first = 'a'.
• q.index('a') = 1 (first 'a' sits at index 1 in the original).

Answers: sorted copy ['a', 'a', 'b', 'b', 'c'], position pos = 1. This is exactly the sorted() vs list.sort() distinction: sorted returns a new list and leaves the original alone.

• e.pop() → ==IndexError== ("pop from empty list") — there is no last item to hand back.
• e.append(1) → returns None; list becomes [1]. Appending to empty is always fine.
• e.count(1) → 0; counting in an empty list is safe and gives zero.
• e.index(1) → ==ValueError== — the value 1 is not present.

Pattern: the Askers/Takers that must find something (pop, index, remove) fail on absence; the counter returns 0 and the adder always works.

Look again at figure s01. pop() removes the last slot — nothing else moves, so the work is a fixed amount regardless of $n$: this is $O(1)$. pop(0) removes the front slot; every remaining item at position $j>0$ must slide left to $j-1$ to close the gap. That is $n-1$ moves, growing with $n$: this is $O(n)$. Same logic mirrors append (fast, end) vs insert(0, x) (slow, front). See Time complexity — append O(1) vs insert O(n).

Inserting at index 0 into a list currently of length $k$ shifts all $k$ existing items right. Doing this for $k=0,1,2,\dots ,n-1$ gives total shifts $0+1+2+\cdots +(n-1)=\frac{n(n-1)}{2}.$ Leading term: $\frac{n^2}{2}$ — quadratic, i.e. $O(n^2)$. Lesson: append then one reverse (as in 4.1) costs about $n$ appends ($O(n)$) plus one reverse ($O(n)$) = $O(n)$ total — far cheaper than front-inserting. Choosing the right end of the list is the whole optimization.

A list method that hands back a value is ==pop, count, or index==. A list method that returns None because it mutates is ==append, insert, remove, sort, or reverse==. remove searches by ::: value (raises ValueError if absent) pop searches by ::: index (raises IndexError if out of range) To sort into a new list without changing the original, use ::: sorted(lst) Front operations cost ::: $O(n)$ because every later item shifts