Garbage collection and array references in NumPy

Introduction

Garbage collection helps clean up memory by removing data no longer needed. Array references let you share or copy data without extra memory use.

When you want to avoid using extra memory by sharing the same array in different parts of your program.

When you want to make a copy of an array to change it without affecting the original.

When you want to understand why changing one array also changes another.

When you want to make sure unused arrays are removed to free memory.

Syntax

NumPy

import numpy as np

# Create an array
original_array = np.array([1, 2, 3])

# Reference assignment (no new array created)
reference_array = original_array

# Copy array (new array created)
copied_array = original_array.copy()

Assigning one array to another variable creates a reference, not a new array.

Using .copy() creates a new array in memory, independent of the original.

Examples

Shows that even empty or single-element arrays can be referenced. Changing the reference changes the original array.

NumPy

import numpy as np

# Empty array reference
empty_array = np.array([])
reference_empty = empty_array

# One element array reference
one_element_array = np.array([10])
reference_one_element = one_element_array

# Changing reference affects original
reference_one_element[0] = 20

Changing the copied array does not affect the original array.

NumPy

import numpy as np

# Copying array
original_array = np.array([5, 6, 7])
copied_array = original_array.copy()
copied_array[0] = 100

Changing array_b changes array_a because they reference the same data.

NumPy

import numpy as np

# Reference assignment
array_a = np.array([1, 2, 3])
array_b = array_a
array_b[1] = 99

Sample Program

This program shows how changing a reference affects the original array, but changing a copy does not.

NumPy

import numpy as np

# Create original array
original_array = np.array([10, 20, 30])
print("Original array before changes:", original_array)

# Create reference to original array
reference_array = original_array

# Create copy of original array
copied_array = original_array.copy()

# Change reference array
reference_array[0] = 100
print("Original array after changing reference:", original_array)

# Change copied array
copied_array[1] = 200
print("Copied array after change:", copied_array)
print("Original array after changing copy:", original_array)

Important Notes

Time complexity for copying an array is O(n), where n is the number of elements.

Assigning a reference is O(1) because no data is copied.

A common mistake is thinking assignment creates a new array; it only creates a new reference.

Use copying when you want to change data without affecting the original array.

Summary

Assigning one array to another variable creates a reference to the same data.

Changing a reference changes the original array because they share data.

Use .copy() to create a new independent array to avoid unwanted changes.

Garbage collection frees memory when arrays are no longer referenced.

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