Lesson 11: Nested Structures, Aliasing & Copies

Nested Structures — Data Inside Data

Real-world data is rarely flat. A student dict contains a list of scores. A company is a list of employee dicts. Python handles any nesting depth — you just need to keep the brackets straight:

employees = [
    {"name": "Amol", "skills": ["python", "ai"]},
    {"name": "Riya", "skills": ["sql", "pandas"]},
]
print(employees[0]["name"])        # Amol
print(employees[0]["skills"][0])   # python

Read nested access outside-in: the outermost bracket first, then work inward.

What You'll Learn in This Lesson

• Build and navigate nested lists and dicts
• Understand aliasing — two names, one object
• Copy safely with shallow vs deep copies
• Distinguish == (value) from is (identity)

Aliasing — Two Names, One Object

This is the trap that confuses every beginner:

original = [1, 2, [3, 4]]
alias = original          # NOT a copy!
alias.append(99)
print(original)           # [1, 2, [3, 4], 99] — original changed too!

When you write b = a, both names point to the SAME list in memory. Change one, and the other changes too. There is only one object — just two labels for it.

Draw arrows: alias and original are two arrows pointing at the same box. There is no second box.

Remember Lesson 2's mental model: = moves a name-tag to an object — it never copies the object. Aliasing is that rule biting back: two tags on one object means one change, two visible effects.

Shallow vs Deep Copy

To get an independent copy, you must ask for one — and there are two depths:

import copy

original = [1, 2, [3, 4]]

shallow = original.copy()
shallow[2].append(100)
print(original)      # [1, 2, [3, 4], 100] — inner list STILL shared!

deep = copy.deepcopy(original)
deep[2].append(200)
print(original)      # [1, 2, [3, 4], 100] — deep copy is fully independent

• A shallow copy creates a new outer container, but the inner objects are still the same objects.
• A deep copy duplicates everything, recursively — nothing is shared.

Mental model: shallow copy = photocopying the outer box but keeping the same inner boxes inside. Deep copy = rebuilding every single box from scratch.

When is shallow copy safe? When your structure is flat — no nested mutable objects. data = [1, 2, 3] copied shallowly is fully independent, because integers are immutable. The problem only appears with nested lists/dicts.

== vs is vs id

Three different questions:

a = [1, 2]
b = a          # same object
c = [1, 2]     # different object, same value
print(a == c)  # True  — same values
print(a is c)  # False — different objects
print(a is b)  # True  — same object

Use == for comparisons in normal code. Use is for singletons (is None, is True) and identity checks.

Professional rule: always compare to None with is — if x is None:, never if x == None:. It is faster, unambiguous, and the universal convention.

The [[0] * 3] * 3 Trap

Creating a matrix the "obvious" way is a classic bug:

bad = [[0] * 3] * 3      # 3 references to the SAME inner list!
bad[0][0] = 1
print(bad)               # [[1, 0, 0], [1, 0, 0], [1, 0, 0]]  — oops!

The * operator repeats references, not copies. The correct way:

good = [[0] * 3 for _ in range(3)]   # 3 independent lists
good[0][0] = 1
print(good)              # [[1, 0, 0], [0, 0, 0], [0, 0, 0]]  — correct!

Why does * on a string or number work fine but fail on a list? Integers and strings are immutable, so sharing is harmless — no one can change a shared 0. Lists are mutable, so every "row" points at the same list you can mutate. The comprehension builds fresh lists each iteration.

Real-World Debugging Flow

When a program "mysteriously" mutates data:

1. Ask: did I copy, or did I alias? Search for bare b = a.
2. Ask: shallow or deep? Nested structures need deepcopy.
3. Verify: print(id(a), id(b)) — identical ids mean one object.
4. Fix: use .copy(), [:], or copy.deepcopy() at the assignment site.

Common Mistakes to Avoid

• Mistake: b = a then mutating b and seeing a change — Fix: use a[:], .copy(), or copy.deepcopy().
• Mistake: Shallow copy on nested data and still seeing shared inner lists — Fix: use copy.deepcopy() for nested structures.
• Mistake: [[0]*3]*3 matrices sharing rows — Fix: build with a comprehension.
• Mistake: x == None instead of x is None — Fix: use is for singletons.
• Mistake: Using is to compare strings/numbers — Fix: is is for identity; use == for values.

Professional Tips & Tricks

• If you need an independent list, always use .copy() or slicing — never bare assignment.
• Use deepcopy only when structures are nested; it is slower.
• Prefer immutable tuples for data you never change — they cannot be aliased-mutated.
• Compare None with is, never ==.
• For nested access, read outside-in and keep the brackets straight.

Key Takeaways

• Nested access reads outside-in; mind the brackets.
• Assignment (b = a) creates an alias, not a copy.
• Shallow copies share inner objects; deep copies share nothing.
• == compares values; is compares identity.
• Build matrices with comprehensions, never [[0]*3]*3.
• Use is None — never == None.

Next up: Module 4 — functions, your reusable building blocks.