Indexing returns views not copies in NumPy - Step-by-Step Execution

Concept Flow - Indexing returns views not copies

Create original array

↓

Index array to get subset

↓

Subset is a view (shares data)

↓

Modify subset

↓

Original array changes too

↓

If copy made, original unchanged

Indexing an array returns a view that shares data with the original array. Changing the view changes the original.

Execution Sample

NumPy

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

Create an array, get a slice view, modify the view, and print original array to see change.

Execution Table

Step	Action	Array state	View state	Note
1	Create arr	[1, 2, 3, 4]	N/A	Original array created
2	Create view = arr[1:3]	[1, 2, 3, 4]	[2, 3]	View shares data with arr
3	Modify view[0] = 20	[1, 20, 3, 4]	[20, 3]	Change in view affects arr
4	Print arr	[1, 20, 3, 4]	N/A	Original array shows updated value

💡 Execution ends after printing arr showing shared data change

Variable Tracker

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

Key Moments - 2 Insights

Why does changing the view also change the original array?

Because the view shares the same data buffer as the original array, so modifying the view modifies the original. See execution_table step 3.

Is the view a separate copy of the data?

No, the view is not a copy but a window into the original array's data. This is why changes reflect back. See execution_table step 2.

Visual Quiz - 3 Questions

Look at the execution table at step 3, what is the value of arr after modifying view?

A [1, 2, 3, 4]

B [20, 3, 3, 4]

C [1, 20, 3, 4]

D [1, 3, 3, 4]

💡 Hint

Check the 'Array state' column at step 3 in execution_table

At which step does the view get created?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

Look at the 'Action' column for when view = arr[1:3] happens

If we changed view[0] without the view sharing data, what would happen to arr?

A arr would also change

B arr would remain unchanged

C arr would become empty

D arr would raise an error

💡 Hint

Refer to the concept that indexing returns views, not copies, in variable_tracker

Concept Snapshot

Indexing a NumPy array returns a view, not a copy.
Modifying the view changes the original array.
Slices share the same data buffer.
To avoid this, use .copy() to make a separate copy.
Remember: view = window, copy = separate data.

Full Transcript

We start by creating a NumPy array arr with values [1, 2, 3, 4]. Then we create a view by slicing arr from index 1 to 3, which gives us [2, 3]. This view shares the same data as arr. When we modify the first element of the view to 20, the original array arr also changes at that position, becoming [1, 20, 3, 4]. Finally, printing arr shows the updated array. This happens because the view is not a copy but a window into the original data. To avoid this, one must explicitly create a copy.

Practice

1. What happens when you create a slice of a NumPy array using indexing like arr[1:4]?

easy

A. It returns a view that shares data with the original array.

B. It returns a completely independent copy of the array slice.

C. It returns a list instead of a NumPy array.

D. It raises an error because slicing is not allowed.

Solution

1. Step 1: Understand NumPy slicing behavior

   In NumPy, slicing an array returns a view, not a copy. This means the new array shares the same data buffer as the original.

2. Step 2: Consequence of view sharing data

   Because the slice is a view, changes to it will affect the original array, confirming it is not an independent copy.

3. Final Answer:

   It returns a view that shares data with the original array. -> Option A

4. Quick Check:

   Indexing slice = view sharing data [OK]

Hint: Slicing returns views, not copies, by default [OK]

Common Mistakes:

• Thinking slicing creates a copy
• Confusing views with copies
• Assuming slicing returns a list

2. Which of the following is the correct way to create a copy of a NumPy array slice so that changes do NOT affect the original array?

easy

A. slice = arr[2:5]

B. slice = arr.copy[2:5]

C. slice = arr[2:5].copy()

D. slice = arr[2:5].view()

Solution

1. Step 1: Identify method to create independent copy

   The .copy() method creates a new array with its own data, independent of the original.

2. Step 2: Check syntax correctness

   Only arr[2:5].copy() correctly calls copy() on the slice. Other options either miss parentheses or use wrong methods.

3. Final Answer:

   slice = arr[2:5].copy() -> Option C

4. Quick Check:

   Use .copy() for independent array [OK]

Hint: Use .copy() after slicing to avoid shared data [OK]

Common Mistakes:

• Forgetting parentheses on .copy()
• Using .view() instead of .copy()
• Assuming slicing alone makes a copy

3. Consider the code:

import numpy as np
arr = np.array([10, 20, 30, 40, 50])
slice_arr = arr[1:4]
slice_arr[0] = 99
print(arr)

What is the output?

medium

A. [10 99 30 40 50]

B. [10 20 30 40 50]

C. [10 99 99 40 50]

D. [10 20 99 40 50]

Solution

1. Step 1: Understand slice is a view

   The slice arr[1:4] returns a view sharing data with arr. Changing slice_arr[0] changes arr[1].

2. Step 2: Apply the change and print

   Setting slice_arr[0] = 99 updates arr[1] to 99. The rest of arr remains unchanged.

3. Final Answer:

   [10 99 30 40 50] -> Option A

4. Quick Check:

   View change updates original array [OK]

Hint: Changing slice changes original array if no copy [OK]

Common Mistakes:

• Expecting original array unchanged
• Changing wrong indices
• Confusing slice indices with original

4. You run this code:

import numpy as np
arr = np.array([1, 2, 3, 4, 5])
slice_arr = arr[1:4]
slice_arr = slice_arr + 10
print(arr)

Why does arr remain unchanged?

medium

A. Because the print statement is incorrect.

B. Because slice_arr + 10 creates a new array, not modifying the view.

C. Because arr is immutable.

D. Because slicing always creates a copy, not a view.

Solution

1. Step 1: Analyze the operation slice_arr + 10

   This operation creates a new array with values increased by 10. It does not modify slice_arr in place.

2. Step 2: Understand assignment effect

   Assigning slice_arr = slice_arr + 10 makes slice_arr point to a new array. The original arr remains unchanged because no in-place modification happened.

3. Final Answer:

   Because slice_arr + 10 creates a new array, not modifying the view. -> Option B

4. Quick Check:

   slice + scalar creates new array, no original change [OK]

Hint: Adding to slice creates new array, original stays same [OK]

Common Mistakes:

• Assuming slice_arr + 10 modifies original array
• Thinking slicing always copies
• Believing arrays are immutable

5. You have a large NumPy array data and want to modify a slice without affecting the original array. Which approach is best to ensure safety and memory efficiency?

hard

A. Use slice = data[100:200] and modify slice directly.

B. Modify data directly without slicing.

C. Use slice = data[100:200].view() and modify slice.

D. Use slice = data[100:200].copy() to modify safely without changing data.

Solution

1. Step 1: Understand views vs copies for safety

   Modifying a view changes the original array. To avoid this, a copy is needed.

2. Step 2: Consider memory efficiency

   Copying only the needed slice with .copy() uses less memory than copying the whole array and ensures safe modification.

3. Step 3: Evaluate other options

   Using slice = data[100:200] and modifying slice directly modifies the original data unintentionally. Using slice = data[100:200].view() and modifying slice creates a view, which is not safe. Modifying data directly without slicing affects the entire array, not just the slice.

4. Final Answer:

   Use slice = data[100:200].copy() to modify safely without changing data. -> Option D

5. Quick Check:

   Copy slice for safe, efficient modification [OK]

Hint: Copy slice to avoid changing original large array [OK]

Common Mistakes:

• Modifying views thinking they are copies
• Copying entire array unnecessarily
• Ignoring memory use in large arrays