A variable is a label (reference) pointing to an object in memory

❌ Variables do NOT store values inside them ✅ Variables REFERENCE objects that store values

Variable (Stack)     Object (Heap)
    x  ─────────────► [10]

• int → object
• str → object
• list → object
• function → object
• module → object

Variables are just labels pointing to heap objects

a = [1, 2]
b = a

a ─┐
   ├──► [1, 2]  (one object in heap)
b ─┘

Both point to SAME object

x = 10
y = x

x ─┐
   ├──► [10]    (immutable, typically same object due to caching)
y ─┘

Reference copied, not value

list, dict, set

❗ Modifications change the SAME object

x = [1, 2]
y = x
y.append(3)
print(x)  # [1, 2, 3]  ← x also changed!

Before: x ─┐
           ├──► [1, 2]
        y ─┘

After:  x ─┐
           ├──► [1, 2, 3]  ← SAME object modified
        y ─┘

int, float, str, tuple

❗ Any modification creates NEW object

x = 10
y = x
y = y + 1  # or y += 1
print(x)   # 10  ← x unchanged
print(y)   # 11

Before: x ─────► [10]
        y ─────┘

After:  x ─────► [10]        (original, unchanged)
        y ─────► [11]        (new object created)

Changes the object itself

x = [1, 2]
x.append(3)  # ← mutation

x ─────► [1, 2, 3]
         (same object, modified)

Points to a different object

x = [1, 2]
x = [3, 4]  # ← rebinding

Before: x ─────► [1, 2]
After:  x ─────► [3, 4]  (new object)

Function parameter receives a REFERENCE to the same object

def modify(lst):
    lst.append(10)  # mutation

a = [1, 2]
modify(a)
print(a)  # [1, 2, 10]  ← changed!

Inside function:
lst ─┐
     ├──► [1, 2, 10]  ← SAME object modified
a ─┘

def modify(lst):
    lst = [999]  # rebinding

a = [1, 2]
modify(a)
print(a)  # [1, 2]  ← unchanged!

Inside function:
lst ─────► [999]  (new local object, function scope only)
a ─────► [1, 2]   (unchanged, still original)

a is b   # → Are they the SAME object? (identity)
a == b   # → Do they have the SAME value? (equality)

• Checks if both variables point to same object in memory
• Compares memory addresses

a = [1, 2]
b = a
print(a is b)  # True  (same object)

• Checks if both objects have same value
• Compares content

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

a = [1, 2]
b = a
c = [1, 2]

b = a

• Creates new variable
• Points to SAME object
• Both see mutations

a ─┐
   ├──► [1, 2]
b ─┘

b = a[:]  # or b = a.copy()

• Creates NEW object
• Copies content at top level
• Mutations don't affect original

a ─────► [1, 2]
b ─────► [1, 2]  (different object, same content)

When analyzing code:

• Track which variable points where
• Not "what value does x hold" but "what object does x refer to"

• Mutable? (list, dict, set)
• Immutable? (int, str, tuple)

• Mutation: x.append(), x[0] = val, x.pop()
• Rebinding: x = new_value

• Mutable + mutation → shared object changes
• Immutable + rebinding → new object created
• Function argument → reference passed, mutation affects original

x = 10  # ❌ "x stores 10"

✔️ Correct: "x is a reference to object 10"

b = a  # ❌ "copied a to b"

✔️ Correct: "b now references the same object as a"

✔️ Correct: "Functions use call-by-sharing (reference passed)"

x = [1]
x += [2]  # ✔️ Mutates (in-place for lists)

y = 10
y += 5    # ❌ Does NOT mutate (creates new int)

✔️ Correct: "Immutable objects create new object, mutable objects may mutate in-place"

1. Everything is an object → stored in heap
2. Variables are references → labels pointing to objects
3. Assignment = reference copy → both point to same object
4. Mutable objects → mutation changes shared object
5. Immutable objects → reassignment creates new object

1️⃣ Draw boxes for objects in heap
2️⃣ Draw arrows for references (variables)
3️⃣ Identify mutable vs immutable
4️⃣ Track mutation vs rebinding
5️⃣ Follow function flow
6️⃣ Predict output

By end of Level 1, you should:

✅ Instantly recognize reference behavior ✅ Explain mutation vs reassignment clearly ✅ Predict output without running code ✅ Distinguish is from == ✅ Handle function arguments confidently

Ready to test? Go to assignement/test folder!

Next Level: Level 2 = nested structures, default arguments, integer caching, string interning, deep copy

Names bind to objects. Assignment rebinds names; mutation changes objects. Keep these two operations separate in your mind.

1. Draw name -> object bindings after each line.
2. Mark object as mutable or immutable.
3. Track aliasing when multiple names point to one object.
4. For functions, treat arguments as new local names bound to passed objects.

Scope and binding time are key: LEGB lookup, closure capture, and default-argument evaluation can preserve unexpected state.

1. Resolve each variable by LEGB.
2. For closures in loops, test late binding assumptions.
3. Check whether defaults are evaluated once at function definition.
4. Fix with explicit rebinding or immutable defaults when needed.

1. After a=[1,2]; b=a; b.append(3), why does a change?
2. In a function, what differs between x.append(1) and x=[1]?
3. Why can two variables have equal values but different identities?

1. How does late binding in closures create surprising loop behavior?
2. Why are mutable default arguments a state-retention trap?
3. Which LEGB step do you check first when debugging shadowed variables?

Understand how this topic runs in actual program flow:

• Read statement
• Resolve type/object/reference
• Execute operation (assignment, mutation, call, return)
• Update memory state (stack/heap bindings)
• Re-check final output from updated state

When you see ANY question:

• Primitive? → value
• Object? → reference

• Primitive → stack
• Object → heap (via reference)

• Primitive → copy value
• Object → copy reference

• Field change → mutation
• new → new object (reassignment)

• Always pass-by-value
• Object → reference copied