Garbage collection and array references in NumPy - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a NumPy array named 'arr' with values from 1 to 5.

NumPy

import numpy as np
arr = np.array([1])

Drag options to blanks, or click blank then click option'

A(1, 2, 3, 4, 5)

B[1, 2, 3, 4, 5]

Crange(1, 6)

D{1, 2, 3, 4, 5}

Attempts:

3 left

💡 Hint

Common Mistakes

Using a tuple instead of a list.

Using a set which is unordered.

Using range object directly without converting to list.

The correct way to create a NumPy array with specific values is to pass a list of those values to np.array(). Here, [1, 2, 3, 4, 5] is a list.

2fill in blank

medium

Complete the code to create a new variable 'ref' that references the same NumPy array as 'arr'.

NumPy

ref = [1]

Drag options to blanks, or click blank then click option'

Aarr

Barr.view()

Carr.copy()

Dnp.array(arr)

Attempts:

3 left

💡 Hint

Common Mistakes

Using copy() which creates a new array.

Using view() which creates a shallow copy.

Creating a new array with np.array() which duplicates data.

Assigning ref = arr makes ref point to the same array object as arr. No new array is created.

3fill in blank

hard

Fix the error in the code to delete the original array and check if 'ref' still exists.

NumPy

import gc
arr = np.array([1, 2, 3])
ref = arr
[1]  # Delete arr
print(ref)

Drag options to blanks, or click blank then click option'

Aarr = None

Barr.clear()

Cgc.collect()

Ddel arr

Attempts:

3 left

💡 Hint

Common Mistakes

Using arr.clear() which is invalid for NumPy arrays.

Calling gc.collect() without deleting references first.

Setting arr to None but not deleting the name.

Using del arr removes the name arr but does not delete the array if other references exist. ref still points to the array.

4fill in blank

hard

Fill both blanks to create a copy of 'arr' and then delete the original reference.

NumPy

copy_arr = arr[1]()
del [2]

Drag options to blanks, or click blank then click option'

Acopy

Barr

Cref

Dview

Attempts:

3 left

💡 Hint

Common Mistakes

Using view() instead of copy() which creates a shallow copy.

Deleting the wrong variable name.

Not deleting any variable.

Calling arr.copy() creates a new array copy. Then deleting arr removes the original reference but copy_arr remains.

5fill in blank

hard

Fill all three blanks to create a view of 'arr', modify it, and then check if 'arr' changed.

NumPy

view_arr = arr[1]()
view_arr[0] = [2]
print(arr[0] == [3])

Drag options to blanks, or click blank then click option'

Aview

B10

Dcopy

Attempts:

3 left

💡 Hint

Common Mistakes

Using copy() which does not affect the original array.

Setting the wrong value in the view.

Comparing to a wrong value in the print statement.

Creating a view with arr.view() means changes to view_arr affect arr. Setting view_arr[0] = 10 changes arr[0] to 10, so the print outputs True.

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