Garbage collection and array references in NumPy - Mini Project: Build & Apply

Garbage Collection and Array References with NumPy

📖 Scenario: You are working with numerical data in Python using NumPy arrays. Understanding how array references and garbage collection work helps you manage memory efficiently when handling large datasets.

🎯 Goal: Build a small program that creates a NumPy array, assigns it to multiple variables, modifies one reference, and then deletes references to observe how garbage collection affects the array.

📋 What You'll Learn

Create a NumPy array with specific values

Assign the array to a second variable (reference)

Modify the array through one reference

Delete one reference and observe the remaining reference

Delete all references to allow garbage collection

💡 Why This Matters

🌍 Real World

Managing memory efficiently is important when working with large datasets in data science or machine learning projects.

💼 Career

Understanding references and garbage collection helps developers write efficient code that avoids memory leaks and unexpected bugs.

1

Create a NumPy array

Import the numpy module as np and create a NumPy array called arr with the values [10, 20, 30, 40, 50].

NumPy

# Import numpy and create the array arr with values [10, 20, 30, 40, 50]
# Your code here

Hint

Use np.array([...]) to create the array.

2

Assign the array to a second variable

Create a new variable called ref_arr and assign it to reference the existing array arr.

NumPy

import numpy as np
arr = np.array([10, 20, 30, 40, 50])
# Assign ref_arr to reference arr
# Your code here

Hint

Just assign ref_arr = arr to create a reference.

3

Modify the array through one reference

Change the second element (index 1) of the array using the ref_arr variable to the value 25.

NumPy

import numpy as np
arr = np.array([10, 20, 30, 40, 50])
ref_arr = arr
# Change the second element of ref_arr to 25
# Your code here

Hint

Use indexing like ref_arr[1] = 25 to modify the array.

4

Delete references to allow garbage collection

Delete the variable arr using the del statement. Then delete ref_arr using del to remove all references to the array.

NumPy

import numpy as np
arr = np.array([10, 20, 30, 40, 50])
ref_arr = arr
ref_arr[1] = 25
# Delete arr and ref_arr to remove references
# Your code here

Hint

Use del arr and del ref_arr to delete the variables.

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