Quiz 3

List Methods, Mutations, Comprehensions & Memory Models (Layered)

2730 words
14 min read
2026-09-12
Python Week 1: the first filter for runtime behavior
Visual companion
Python
Type and operator map

Python Week 1: the first filter for runtime behavior

Open galleryRelated surface
View
Revision summary

What this note is really saying

Short form

Layered chapter on Python lists: memory models, reference aliasing, shallow vs deep copying, list comprehensions, sorting keys, and question-pattern anatomy. # List Methods, Mutations, Comprehensions & Memory Models > **Acceptance Standard:** This chapter serves as an exhaustive, self-contained textbook for any stud...

List Methods, Mutations, Comprehensions & Memory Models

Acceptance Standard: This chapter serves as an exhaustive, self-contained textbook for any student preparing for IIT Madras BSCS1002 (Programming in Python) Quiz 2, Quiz 3, or OPPE. It breaks down memory addresses, pointer aliasing, in-place vs non-mutating operations, and list comprehension mechanics with zero hand-waving.

1. Orientation & Mental Model

The Box vs. The Label: Python's Reference Model

In languages like C or Pascal, a variable is often imagined as a memory box holding raw bytes. If you write int a = 5; int b = a;, the integer 5 is copied into two distinct boxes.
In Python, variables are never boxes; they are sticky labels attached to heap objects.
Heap Object:    [  10,  20,  30  ]  (list at 0x104A)
                  ^          ^
                  |          |
Label:            a          b
When you execute:
python
a = [10, 20, 30]
b = a
b.append(40)
print(a)  # Output: [10, 20, 30, 40]
You did not create two lists. You created two labels pointing to the exact same list in memory. When you mutate b, anyone looking through label a sees the change immediately.

The Two Fundamental Axes of List Operations

Every list operation in Python sits on two crucial axes:
  1. Mutation Axis: Does this operation alter the existing heap object in-place, or does it allocate a fresh list at a new memory address?
  2. Return Value Axis: Does this method return None (standard for in-place mutators), or does it evaluate to a result?
Confusing these two axes is the single most common cause of negative marks in BSCS1002 exams.

2. Terminology, Notation & Etymology

TermPython SyntaxEtymology / OriginExact Technical Meaning
Mutablelist, dict, setLatin mutabilis ("subject to change, inconstant").An object whose internal state or payload can be modified in-place without altering its memory identity (id()).
Immutableint, str, tuple, frozensetLatin immutabilis ("unchanging").An object whose value cannot change after allocation. Any transformation produces a brand new heap object.
Aliasingb = aLatin alias ("at another time, otherwise, under another name").When two or more variable identifiers reference the identical object address in memory (a is b == True).
Shallow Copya.copy(), a[:], list(a)—A new outer container is allocated, but its internal elements are references pointing to the exact same objects as the original.
Deep Copycopy.deepcopy(a)—A completely recursive duplication where the outer container and all nested compound objects are recursively cloned.
In-Place Mutationlst.sort(), lst.reverse()Latin in situ ("in its original place").Modifying the elements inside the caller's existing memory buffer; evaluates to None.
Comprehension[expr for x in seq if cond]Latin comprehendere ("to grasp together, encompass").A concise syntactic form derived from mathematical set-builder notation to map, filter, and construct sequences in C-speed bytecode.
Key Functionkey=len, key=lambda x: x[1]—A unary callable passed to sort() or sorted() that maps each item to a comparison proxy without mutating the original elements.

3. Foundational Mechanics: The Comprehensive Method Inventory

In-Place Mutators (Return None)

MethodSyntaxActionTime ComplexityTrap to Avoid
appendlst.append(x)Appends single element x to end.O(1)O(1) amortizedlst.append([1, 2]) adds a nested list as 1 element, NOT individual items!
extendlst.extend(iterable)Unpacks and appends every element from iterable.O(k)O(k) for kk itemsPassing a string lst.extend("cat") adds 'c', 'a', 't' individually!
insertlst.insert(i, x)Inserts element x at index i, shifting existing items right.O(n)O(n)Inserting at index 0 requires shifting all nn items: slow for large datasets.
removelst.remove(x)Deletes the first occurrence of value x.O(n)O(n)Raises ValueError if x is not present in lst.
poplst.pop(i=-1)Removes and returns the element at index i.O(1)O(1) at end, O(n)O(n) elsewhereDefault is the last element (i = -1). Returns the removed element, unlike other mutators!
clearlst.clear()Removes all elements; length becomes 0.O(n)O(n)Leaves the container object intact (id(lst) remains unchanged).
sortlst.sort(key=None, reverse=False)Sorts the list in-place using Timsort.O(nlog⁡n)O(n \log n)Evaluates to None! Writing x = lst.sort() destroys your reference (x is None).
reverselst.reverse()Reverses elements in-place.O(n)O(n)Evaluates to None! Do not write lst = lst.reverse().

Non-Mutating Observers (Return Values)

MethodSyntaxActionReturn ValueTrap to Avoid
indexlst.index(x, [start, end])Returns lowest index where value x appears.intRaises ValueError if x is absent. Always check if x in lst: first!
countlst.count(x)Returns number of occurrences of x.intReturns 0 if absent (never raises an error).
copylst.copy()Allocates a shallow copy.New listNested lists inside the copy still share identical memory with the original!

4. Algorithmic Depth: Memory Anatomy & Comprehensions

Layer 1: The Three Tiers of Copying

To master exam questions involving nested structures (e.g. matrices matrix = [[0]*3]*3), you must trace the 3 tiers of copying:
Tier 1: Aliasing (b = a)
a ──┐
    ├──> [ List Header | ptr0, ptr1, ptr2 ] ──> Items in Heap
b ──┘

Tier 2: Shallow Copy (c = a.copy() or a[:])
a ──> [ Header A | ptr0, ptr1, ptr2 ] ──┐
                                          ├──> Shared Inner Heap Objects!
c ──> [ Header C | ptr0, ptr1, ptr2 ] ──┘

Tier 3: Deep Copy (d = copy.deepcopy(a))
a ──> [ Header A | ptrA0, ptrA1 ] ──> [ Inner Object A ]
d ──> [ Header D | ptrD0, ptrD1 ] ──> [ Inner Object D (Clone) ]

The Famous Matrix Multiplication / Grid Initialization Bug

Consider creating a 3×33 \times 3 grid of zeros:
python
# ❌ THE FATAL ALIASING BUG:
grid = [[0] * 3] * 3
grid[0][0] = 99
print(grid)
# Output: [99, 0, 0], [99, 0, 0], [99, 0, 0](/courses/bscs1002/notes/99%2C%200%2C%200%5D%2C%20%5B99%2C%200%2C%200%5D%2C%20%5B99%2C%200%2C%200)
Why did all three rows change? [0] * 3 creates a single list [0, 0, 0]. The outer * 3 replicates the reference to that exact same list 3 times! grid[0], grid[1], and grid[2] all point to identical memory.
python
# ✅ THE CORRECT LIST COMPREHENSION INITIALIZATION:
grid = [[0 for _ in range(3)] for _ in range(3)]
grid[0][0] = 99
print(grid)
# Output: [99, 0, 0], [0, 0, 0], [0, 0, 0](/courses/bscs1002/notes/99%2C%200%2C%200%5D%2C%20%5B0%2C%200%2C%200%5D%2C%20%5B0%2C%200%2C%200)
Each iteration of the outer comprehension evaluates [0 for _ in range(3)] anew, creating 3 distinct list objects.

Layer 2: List Comprehensions Grammar & Execution Order

A list comprehension is an inline pipeline. To read and write any comprehension without hesitation, master its formal syntax grammar:

Pattern A: Filtering & Mapping (Condition at the End)

[ Transform(x) for x in Iterable if Filter(x) ]\text{[ \textbf{Transform(x)} for \textbf{x} in \textbf{Iterable} if \textbf{Filter(x)} ]}
Execution order:
  1. for x in Iterable (takes next item)
  2. if Filter(x) (evaluates truthiness; if False, skips item)
  3. Transform(x) (evaluates final expression and appends to new list)
python
# Extract uppercase strings longer than 3 characters
words = ["apple", "bat", "cherry", "dog", "elderberry"]
result = [w.upper() for w in words if len(w) > 3]
# result: ['APPLE', 'CHERRY', 'ELDERBERRY']

Pattern B: Conditional Value Selection (Ternary if-else in Expression)

[ Val_If_True if Condition else Val_If_False for x in Iterable ]\text{[ \textbf{Val\_If\_True} if \textbf{Condition} else \textbf{Val\_If\_False} for \textbf{x} in \textbf{Iterable} ]}
python
# Label numbers as 'even' or 'odd'
numbers = [1, 2, 3, 4, 5]
labels = ["even" if n % 2 == 0 else "odd" for n in numbers]
# labels: ['odd', 'even', 'odd', 'even', 'odd']
Important
Syntax Grammar Rule:
  • If you want to filter out items (shortening the list), if goes at the end (no else permitted).
  • If you want to transform every item into one of two options (preserving length), the if-else ternary goes at the beginning.

Pattern C: Nested Comprehensions (Flattening Matrices)

python
matrix = [1, 2, 3], [4, 5, 6], [7, 8, 9](/courses/bscs1002/notes/1%2C%202%2C%203%5D%2C%20%5B4%2C%205%2C%206%5D%2C%20%5B7%2C%208%2C%209)
flat = [x for row in matrix for x in row]
# flat: [1, 2, 3, 4, 5, 6, 7, 8, 9]
Mnemonic for nested comprehensions: Read the for loops left-to-right in the exact same order you would write nested traditional loops:
python
for row in matrix:
    for x in row:
        flat.append(x)

5. Failure Modes & Common Exam Traps

Trap 1: Capturing the Return Value of In-Place Mutators

python
# EXAM CODE SNIPPET:
nums = [4, 1, 3, 2]
nums = nums.sort()
print(nums)
  • Student expectation: [1, 2, 3, 4]
  • Actual output: None
  • Root cause: nums.sort() mutates in-place and evaluates to None. Overwriting nums destroys the list.
  • Remedy: Either call nums.sort() by itself on its own line, or use the non-mutating built-in function nums = sorted(nums).

Trap 2: Modifying a List While Iterating Over It

python
# EXAM CODE SNIPPET: Remove all even numbers
nums = [2, 4, 6, 7, 8]
for x in nums:
    if x % 2 == 0:
        nums.remove(x)
print(nums)
  • Student expectation: [7]
  • Actual output: [4, 7]!
  • Root cause: When 2 at index 0 is removed, 4 shifts into index 0. The loop advances to index 1, which now contains 6, completely skipping 4!
  • Golden Rule: Never add or remove items from a sequence while iterating over it. Iterate over a slice copy instead: for x in nums[:]:.

Trap 3: extend() vs append() with Iterables

python
a = [1, 2]
b = [3, 4]

a.append(b)  # a is now [1, 2, [3, 4]] -> length is 3!
a.extend(b)  # a is now [1, 2, [3, 4], 3, 4] -> length is 5!

6. Question-Pattern Anatomy (8 Finite Exam Shapes)

Shape 1: Variable Aliasing and In-Place Mutation Tracking

  • Cue: Two variables initialized via b = a, followed by method calls on b.
  • Attack: Check if b was assigned via b = a (alias), b = a[:] (shallow copy), or b = copy.deepcopy(a). If aliased, all mutations on b affect a.

Shape 2: Return Type Discrimination (sort vs sorted, reverse vs reversed)

  • Cue: x = a.reverse() or y = sorted(a).
  • Attack:
    • .sort() and .reverse() return None.
    • sorted() returns a brand new list.
    • reversed() returns a lazy list_reverseiterator.

Shape 3: Shallow Copy Mutation in 2D Matrices

  • Cue: row = [0, 0]; grid = [row, row]; grid[0][1] = 5.
  • Attack: Check id(grid[0]) == id(grid[1]). Because both point to row, grid[1][1] is also modified to 5.

Shape 4: Tracing Nested List Comprehensions

  • Cue: A one-line comprehension with two for clauses or an if-else ternary.
  • Attack: Unroll the comprehension into standard multi-line indentation. Track the evaluation sequence strictly from outer loop →\to inner loop →\to expression.

Shape 5: Custom Key Sorting with Lambdas & Tuples

  • Cue: students.sort(key=lambda s: (-s['marks'], s['name'])).
  • Attack:
    1. Negative -s['marks'] sorts marks descending.
    2. s['name'] acts as the tie-breaker, sorting alphabetically ascending.

Shape 6: Slicing Assignment & In-Place Replacement

  • Cue: lst[1:3] = [80, 90, 100].
  • Attack: Slicing assignment can change the length of the list! Elements between index 1 and 3 are removed and replaced by the entire contents of the right-hand iterable.

Shape 7: Indexing Out of Range vs Slicing Out of Range

  • Cue: lst = [10, 20]; print(lst[5]) vs print(lst[1:5]).
  • Attack:
    • Direct index access lst[5] raises IndexError.
    • Slices never raise IndexError! lst[1:5] gracefully truncates to available bounds [20].

Shape 8: Iteration Skipping During Dynamic Removal

  • Cue: A for x in a: loop containing a.remove(x) or del a[i].
  • Attack: Trace the internal index pointer step-by-step. Whenever an item is deleted, all subsequent items shift left by 1 index, causing the immediate next neighbor to be skipped.

7. Interactive Verification & Attempt-First Self-Checks

1

Question 1

Type: MCQ | Marks: 1 | Topic: Shallow copy & nested list mutation
Consider the following Python script:
python
x = [1, 2, [3, 4]]
y = x.copy()
y[0] = 99
y[2].append(5)

print(x)
What is the exact output printed to the console?
MCQ
Shallow copy & nested list mutation
3 Unit Assessment
A
[1, 2, [3, 4]]
B
[99, 2, [3, 4, 5]]
C
[1, 2, [3, 4, 5]]
D
[99, 2, [3, 4]]
2

Question 2

Type: MCQ | Marks: 1 | Topic: List comprehension with ternary and filter
Consider the following list comprehension:
python
vals = [x * 2 if x % 2 == 0 else x * 3 for x in range(6) if x > 1]
What is the value of vals?
MCQ
List comprehension with ternary and filter
3 Unit Assessment
A
[4, 9, 8, 15]
B
[0, 3, 4, 9, 8, 15]
C
[6, 8, 10]
D
[4, 6, 8, 10, 12]
3

Question 3

Type: MCQ | Marks: 1 | Topic: String sorting vs key=int sorting
What is the output of the following snippet?
python
data = ["10", "2", "30", "4"]
data.sort()
first = data[0]

data.sort(key=int)
second = data[0]

print(first, second)
MCQ
String sorting vs key=int sorting
3 Unit Assessment
A
2 2
B
10 2
C
10 4
D
2 10

8. Next Action & Spacing Rail

Chapter provenance: authored 2026-09-12 to the layered-chapter standard (docs/roadmaps/2026-09-12-claude-content-ecosystem.md, syntax per docs/authoring/AUTHORING_COOKBOOK.md), scoped against the BSCS1002 syllabus vault and the imported 790 - List Methods & Advanced Operations.md (untouched; this file is its new sibling).
Document outline

Keep your place and jump directly to a heading.

Table of contents

No note selected

Open a chapter to see its outline, backlinks, and sources here.

Open libraryCheckpoint desk