Garbage collection and array references in NumPy - Step-by-Step Execution

Concept Flow - Garbage collection and array references

Create array A

↓

Assign B = A (reference)

↓

Modify B affects A

↓

Delete A

↓

B still holds reference

↓

Delete B

↓

No references left -> Garbage collected

This flow shows how arrays share references, how deleting one reference doesn't delete the data until all references are gone, triggering garbage collection.

Execution Sample

NumPy

import numpy as np
A = np.array([1, 2, 3])
B = A
B[0] = 10
del A
del B

This code creates a numpy array, assigns it to another variable, modifies it, then deletes references to show when garbage collection happens.

Execution Table

Step	Action	Array A	Array B	Reference Count	Garbage Collection
1	Create A	[1, 2, 3]	None	1	No
2	Assign B = A	[1, 2, 3]	[1, 2, 3]	2 (shared)	No
3	Modify B[0] = 10	[10, 2, 3]	[10, 2, 3]	2 (shared)	No
4	Delete A	Deleted	[10, 2, 3]	1	No
5	Delete B	Deleted	Deleted	0	Yes

💡 All references deleted at step 5, array memory is garbage collected.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5
A	[1, 2, 3]	[1, 2, 3]	[10, 2, 3]	Deleted	Deleted
B	None	[1, 2, 3]	[10, 2, 3]	[10, 2, 3]	Deleted
Reference Count	1	2	2	1	0

Key Moments - 3 Insights

Why does modifying B also change A's values?

Because B is just another name (reference) for the same array as A, so changes via B affect the same data (see execution_table step 3).

Why isn't the array deleted when we delete A?

Deleting A only removes one reference; B still points to the array, so it stays in memory (see execution_table step 4).

When does garbage collection actually happen?

Garbage collection happens only when all references are deleted, here after deleting B at step 5 (see exit_note).

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is the value of array A?

A [1, 2, 3]

B Deleted

C [10, 2, 3]

D None

💡 Hint

Check the 'Array A' column at step 3 in execution_table.

At which step does the reference count drop to zero?

A Step 4

B Step 5

C Step 3

D Step 2

💡 Hint

Look at the 'Reference Count' column in variable_tracker after each step.

If we did not delete B at step 5, what would happen to the array?

A It would remain in memory

B It would be garbage collected anyway

C It would cause an error

D It would be copied automatically

💡 Hint

See explanation in key_moments about when garbage collection happens.

Concept Snapshot

Garbage collection in numpy depends on references.
Assigning one array to another shares the same data.
Modifying one reference changes the original array.
Deleting a reference removes one pointer.
Data is freed only when all references are deleted.
Use del to remove references and trigger garbage collection.

Full Transcript

This lesson shows how numpy arrays are managed in memory using references. When you assign one array to another variable, both variables point to the same data. Changing the array through one variable changes it for the other too. Deleting one variable only removes one reference; the data stays as long as another reference exists. Garbage collection happens only when all references are deleted, freeing the memory. This is important to understand to avoid unexpected changes and memory leaks.

Practice

1. What happens when you assign one NumPy array to another variable without using .copy()?

easy

A. The array data is converted to a list.

B. A new independent copy of the array is created.

C. Both variables refer to the same array data in memory.

D. The original array is deleted from memory.

Solution

1. Step 1: Understand assignment behavior in NumPy

   Assigning one array to another variable without .copy() does not create a new array but a reference to the same data.

2. Step 2: Effect of shared references

   Both variables point to the same memory location, so changes via one variable affect the other.

3. Final Answer:

   Both variables refer to the same array data in memory. -> Option C

4. Quick Check:

   Assignment without copy = shared reference [OK]

Hint: Assignment copies reference, not data, unless .copy() used [OK]

Common Mistakes:

• Thinking assignment creates a new array copy
• Assuming changes to one variable don't affect the other
• Confusing assignment with .copy() method

2. Which of the following is the correct syntax to create an independent copy of a NumPy array a?

easy

A. b = a.copy()

B. b = a

C. b = copy(a)

D. b = a[:]

Solution

1. Step 1: Identify the method for copying arrays

   The .copy() method creates a new independent array with its own data.

2. Step 2: Check other options

   Assignment b = a shares data; copy(a) is invalid without import; slicing a[:] creates a view, not a full copy.

3. Final Answer:

   b = a.copy() -> Option A

4. Quick Check:

   Use .copy() for independent array [OK]

Hint: Use .copy() method to avoid shared data [OK]

Common Mistakes:

• Using simple assignment expecting a copy
• Using slicing which creates a view, not a copy
• Calling copy() without importing copy module

3. Consider the code:

import numpy as np
x = np.array([1, 2, 3])
y = x
y[0] = 10
print(x)

What is the output?

medium

A. [10 2 3]

B. [1 2 3]

C. [0 2 3]

D. Error: assignment to y does not affect x

Solution

1. Step 1: Understand reference assignment

   Variable y is assigned to x, so both refer to the same array.

2. Step 2: Effect of modifying y on x

   Changing y[0] to 10 changes the shared array, so x[0] is also 10.

3. Final Answer:

   [10 2 3] -> Option A

4. Quick Check:

   Shared reference means change reflects in both [OK]

Hint: Modifying reference changes original array if no copy [OK]

Common Mistakes:

• Expecting original array to remain unchanged
• Confusing assignment with copy
• Thinking print will show error

4. What is wrong with this code snippet?

import numpy as np
x = np.array([1, 2, 3])
y = x[:]
y[0] = 5
print(x)

medium

A. Slicing creates a copy, so x remains unchanged.

B. Syntax error in slicing syntax.

C. y is not defined before assignment.

D. Slicing creates a view, so modifying y changes x.

Solution

1. Step 1: Understand slicing behavior in NumPy

   Slicing an array creates a view, not a copy, so y shares data with x.

2. Step 2: Effect of modifying y on x

   Changing y[0] to 5 modifies the shared data, so x[0] also becomes 5.

3. Final Answer:

   Slicing creates a view, so modifying y changes x. -> Option D

4. Quick Check:

   Slicing = view, not copy [OK]

Hint: Slicing shares data; use .copy() for independent array [OK]

Common Mistakes:

• Assuming slicing creates a copy
• Expecting original array to stay unchanged
• Thinking slicing causes syntax error

5. You have a large NumPy array a used in multiple variables. You want to free memory used by a when no longer needed. Which statement is TRUE about garbage collection in this context?

hard

A. You must manually call a special function to free NumPy array memory.

B. Deleting all references to a allows Python to free its memory automatically.

C. NumPy arrays never get garbage collected automatically.

D. Assigning a = None immediately frees the memory even if other references exist.

Solution

1. Step 1: Understand Python garbage collection

   Python frees memory of objects when no references to them remain.

2. Step 2: Effect of references on NumPy arrays

   NumPy arrays are freed automatically when all variables referencing them are deleted or reassigned.

3. Final Answer:

   Deleting all references to a allows Python to free its memory automatically. -> Option B

4. Quick Check:

   Garbage collection frees unreferenced arrays [OK]

Hint: Remove all references to free array memory automatically [OK]

Common Mistakes:

• Thinking manual memory free is needed
• Assuming assigning None frees memory if other refs exist
• Believing NumPy arrays are exempt from garbage collection