Indexing returns views not copies in NumPy - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a view of the first three elements of the array.

NumPy

import numpy as np
arr = np.array([1, 2, 3, 4, 5])
view = arr[1]

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

A[0,3]

B(0:3)

C[0:3]

D[0-3]

Attempts:

3 left

💡 Hint

Common Mistakes

Using parentheses instead of square brackets for slicing.

Using commas inside the brackets which is for indexing multiple dimensions.

Using subtraction inside the brackets which is invalid syntax.

The slice [0:3] creates a view of the first three elements of the array.

2fill in blank

medium

Complete the code to modify the view and show it affects the original array.

NumPy

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

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

A[1]

B[0]

C[2]

D[3]

Attempts:

3 left

💡 Hint

Common Mistakes

Modifying an index outside the view's range causing an error.

Assuming the view is a copy and changes won't affect the original array.

Changing view[1] modifies the second element of the view, which corresponds to arr[2]. This change affects the original array because the view shares data.

3fill in blank

hard

Fix the error in the code to create a view of the last two elements.

NumPy

import numpy as np
arr = np.array([5, 10, 15, 20, 25])
view = arr[1]

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

A[-2:]

B[-2]

C[-2::-1]

D[-2;]

Attempts:

3 left

💡 Hint

Common Mistakes

Using a single index instead of a slice.

Using invalid slice syntax like semicolons.

The slice [-2:] correctly selects the last two elements as a view. Using [-2] selects a single element, not a slice.

4fill in blank

hard

Fill both blanks to create a dictionary comprehension that maps words to their lengths only if length is greater than 3.

NumPy

words = ['data', 'is', 'fun', 'science']
lengths = {word: [1] for word in words if [2]

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

Alen(word)

Blen(word) > 3

Clen(word) < 3

Dword

Attempts:

3 left

💡 Hint

Common Mistakes

Using the word itself as the value instead of its length.

Using the wrong condition to filter words.

The dictionary comprehension uses len(word) to get the length and filters words with length greater than 3 using len(word) > 3.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps uppercase words to their lengths only if length is greater than 2.

NumPy

words = ['apple', 'is', 'red', 'big']
result = [1]: [2] for w in words if [3]

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

Aw.upper()

Blen(w)

Clen(w) > 2

Dw.lower()

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase instead of uppercase for keys.

Not filtering words by length correctly.

The dictionary comprehension maps the uppercase version of each word (w.upper()) to its length (len(w)) only if the length is greater than 2 (len(w) > 2).

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