Views share memory with originals in NumPy - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does it mean when a NumPy view shares memory with the original array?

It means that the view and the original array point to the same data in memory. Changing one will change the other.

beginner

How can you create a view of a NumPy array?

You can create a view by slicing the array or using the view() method.

beginner

What happens if you modify a view of a NumPy array?

Modifying the view changes the original array because they share the same memory.

intermediate

How can you check if two NumPy arrays share the same memory?

Use the np.shares_memory(array1, array2) function to check if they share memory.

intermediate

What is the difference between a view and a copy in NumPy?

A view shares memory with the original array, so changes affect both. A copy has its own memory, so changes do not affect the original.

What does slicing a NumPy array usually return?

A A view sharing memory with the original array

B A completely independent copy

C A Python list

D An error

Slicing a NumPy array usually returns a view that shares memory with the original array.

If you change a value in a NumPy view, what happens to the original array?

A It remains unchanged

B It changes as well

C It raises an error

D It creates a new array

Because views share memory with the original array, changes in the view affect the original.

Which function checks if two arrays share memory in NumPy?

A np.copy()

B np.array_equal()

C np.shares_memory()

D np.view()

np.shares_memory() returns True if two arrays share the same memory.

What method can explicitly create a view of a NumPy array?

A array.flatten()

B array.copy()

C array.tolist()

D array.view()

The view() method creates a new view of the array sharing the same data.

Which statement is true about copies in NumPy?

A Copies do not share memory with the original array

B Copies cannot be created

C Copies are always views

D Copies share memory with the original array

Copies have their own memory and do not affect the original array when changed.

Explain what happens when you modify a NumPy view and how it relates to the original array.

Think about how memory is shared between view and original.

Describe how to check if two NumPy arrays share the same memory and why this might be useful.

Consider when you want to avoid unintended changes.

Practice

1. What happens when you modify a NumPy array view?

easy

A. An error occurs because views are read-only

B. Only the view changes, original stays same

C. A new copy of the array is created

D. The original array also changes

Solution

1. Step 1: Understand what a view is

   A view is a way to look at the same data without copying it.

2. Step 2: Effect of modifying a view

   Since the view shares memory with the original, changing the view changes the original array too.

3. Final Answer:

   The original array also changes -> Option D

4. Quick Check:

   Views share memory = original changes [OK]

Hint: Views share memory; changing view changes original [OK]

Common Mistakes:

• Thinking views create copies
• Assuming views are independent
• Believing views are read-only

2. Which of the following is the explicit way to create a view of a NumPy array a?

easy

A. b = a.view()

B. b = a.copy()

C. b = a[:]

D. b = np.array(a)

Solution

1. Step 1: Identify methods to create views

   The view() method explicitly creates a view sharing memory with the original array.

2. Step 2: Check other options

   copy() and np.array() create copies, not views. a[:] creates a view only if a is an ndarray, but view() is the explicit and recommended method.

3. Final Answer:

   b = a.view() -> Option A

4. Quick Check:

   Use view() for views [OK]

Hint: Use .view() method to create a view [OK]

Common Mistakes:

• Using copy() instead of view()
• Assuming slicing always creates a copy
• Using np.array() which copies data

3. What is the output of this code?

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

medium

A. [1 2 3 4]

B. [10 2 3 4]

C. [1 10 3 4]

D. [1 2 10 4]

Solution

1. Step 1: Understand slicing creates a view

   The slice x[1:3] creates a view of elements at index 1 and 2.

2. Step 2: Modify the view and check original

   Changing y[0] changes x[1] because they share memory. So x becomes [1, 10, 3, 4].

3. Final Answer:

   [1 10 3 4] -> Option C

4. Quick Check:

   Slices are views = original changes [OK]

Hint: Slicing creates views; changes reflect in original [OK]

Common Mistakes:

• Thinking slicing creates a copy
• Modifying view does not affect original
• Confusing indices in slice

4. Find the error in this code that tries to create a view and modify it:

import numpy as np
arr = np.array([5, 6, 7, 8])
view_arr = arr.copy()
view_arr[1] = 100
print(arr)

medium

A. copy() creates a view, so arr changes

B. copy() creates a copy, so arr does not change

C. Syntax error in creating view

D. view_arr is read-only, cannot assign

Solution

1. Step 1: Understand copy() behavior

   copy() creates a new array with its own memory, not a view.

2. Step 2: Effect of modifying copy

   Changing view_arr[1] does not affect arr because they are separate arrays.

3. Final Answer:

   copy() creates a copy, so arr does not change -> Option B

4. Quick Check:

   copy() makes independent array [OK]

Hint: copy() makes independent array, not view [OK]

Common Mistakes:

• Assuming copy() creates a view
• Expecting original to change after copy modification
• Confusing copy() and view()

5. You have a large NumPy array data. You want to modify a small part without copying the whole array to save memory. Which approach is best?

hard

A. Use slicing or view() to get a view and modify it

B. Convert array to list, modify, then back to array

C. Use data.copy() and modify the copy

D. Use np.array(data) to create a new array and modify

Solution

1. Step 1: Understand memory use in copying vs views

   Copying creates a full new array, using more memory. Views share memory and are efficient.

2. Step 2: Choose method to modify part without full copy

   Slicing or view() creates a view sharing memory, so modifying it changes original without extra memory.

3. Final Answer:

   Use slicing or view() to get a view and modify it -> Option A

4. Quick Check:

   Views save memory and allow modification [OK]

Hint: Use views to modify without copying large arrays [OK]

Common Mistakes:

• Using copy() wastes memory
• Converting to list is slow and memory heavy
• Creating new arrays duplicates data unnecessarily