Views share memory with originals in NumPy - Step-by-Step Execution

Concept Flow - Views share memory with originals

Create original array

↓

Create view from original

↓

Modify view

↓

Original array changes too

↓

Modify original

↓

View reflects original changes

This flow shows how creating a view from a numpy array links their memory, so changes in one affect the other.

Execution Sample

NumPy

import numpy as np
arr = np.array([1, 2, 3])
view = arr[1:]
view[0] = 10
print(arr)

Create an array, make a view slice, change the view, and print original to see shared memory effect.

Execution Table

Step	Action	Array 'arr'	View 'view'	Notes
1	Create arr = [1, 2, 3]	[1, 2, 3]	N/A	Original array created
2	Create view = arr[1:]	[1, 2, 3]	[2, 3]	View shares memory with arr from index 1
3	Modify view[0] = 10	[1, 10, 3]	[10, 3]	Change in view updates arr too
4	Print arr	[1, 10, 3]	[10, 3]	Original array shows updated value
5	Modify arr[2] = 20	[1, 10, 20]	[10, 20]	Change in arr updates view
6	Print view	[1, 10, 20]	[10, 20]	View reflects arr's change
7	End	[1, 10, 20]	[10, 20]	Execution ends

💡 All steps complete; shows how view and original share memory and reflect changes mutually.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 5	Final
arr	[1, 2, 3]	[1, 2, 3]	[1, 10, 3]	[1, 10, 20]	[1, 10, 20]
view	N/A	[2, 3]	[10, 3]	[10, 20]	[10, 20]

Key Moments - 3 Insights

Why does changing 'view[0]' also change 'arr[1]'?

Because 'view' is a view, not a copy, it shares the same memory as 'arr' starting at index 1. So modifying 'view[0]' changes 'arr[1]' as shown in execution_table step 3.

If I change 'arr[2]', why does 'view[1]' change too?

Since 'view' points to the same memory slice of 'arr', changing 'arr[2]' updates 'view[1]' as seen in execution_table step 5.

Is 'view' a separate array with its own data?

No, 'view' is a window into 'arr' data, sharing memory. Changes in one reflect in the other, unlike a copy.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is the value of arr after modifying view[0]?

A [10, 2, 3]

B [1, 2, 3]

C [1, 10, 3]

D [1, 3, 10]

💡 Hint

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

At which step does changing arr affect the view?

A Step 3

B Step 5

C Step 2

D Step 4

💡 Hint

Look at the 'Action' and 'View view' columns at step 5 in the execution_table.

If we changed 'view' by making a copy instead of a view, what would happen?

A Changes in view would not affect arr

B Changes in arr would update view

C Both would update each other

D View would stop existing

💡 Hint

Recall that views share memory but copies do not; see key_moments about shared memory.

Concept Snapshot

Numpy views share memory with the original array.
Creating a view (e.g., arr[1:]) does not copy data.
Modifying the view changes the original array.
Modifying the original array changes the view.
Use views to save memory but be careful with side effects.

Full Transcript

This lesson shows how numpy views share memory with the original array. We start by creating an array 'arr' with values [1, 2, 3]. Then we create a view 'view' by slicing arr from index 1. This view shares the same memory as arr starting at index 1. When we change view[0] to 10, arr[1] also changes to 10, showing the shared memory effect. Later, changing arr[2] to 20 updates view[1] to 20. This means changes in either the view or the original array reflect in the other. Views are not copies but windows into the same data. This is useful for saving memory but requires care to avoid unexpected 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