Indexing on ndarrays - use Technical Quotient

1. Remember

What is the output of x[np.array([3, 3, -3, 8])] given x = np.arange(10, 1, -1)?

array([4, 4, 7, 2])

array([7, 7, 7, 2])

array([3, 3, 4, 8])

array([7, 7, 4, 2])

Correct; indexes 3 and 8 select 7 and 2 from x, and -3 (the third element from the end) selects 4.

2. Understand

Why does x[np.array([3, 3, -3, 8])] return array([7, 7, 4, 2]) for x = np.arange(10, 1, -1)?

Positive and negative indices select elements directly from x based on their positions.
Only positive indices are valid, negative indices return the first element.
The array x is sorted before indices are applied.

Incorrect; the array x is not sorted or altered before indexing.

Negative indices reverse the array before selection.

4. Apply

Given y = np.arange(35).reshape(5, 7), how would you select the elements 0, 15, and 30 using integer array indexing?

y[[0, 15, 30]]

y[np.array([0, 2, 4])]

y[:, [0, 2, 4]]

y[np.array([0, 2, 4]), np.array([0, 1, 2])]

5. Apply

How can you use broadcasting with integer array indexing to select the corner elements 0, 2, 9, and 11 from x = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]])?

x[[0, 3]][[0, 2]]

x[:, [0, 2]]

x[[0, 3], [0, 2]]

Incorrect; direct indexing like this without np.ix_ would only select diagonal elements.

x[np.ix_([0, 3], [0, 2])]

Correct; np.ix_ allows for broadcasting index arrays to select specific elements, like corners.

6. Analyze

Why does using x[[0, 1, 2], [0, 1, 0]] return array([1, 4, 5]) from x = np.array([[1, 2], [3, 4], [5, 6]])?

It selects elements based on paired indices from the provided index arrays, matching row with column.

Correct; the provided row and column indices pair up to select specific elements ([0,0], [1,1], [2,0]).

It selects the maximum value from each specified row and column.
It creates a new array from the sum of the specified indices.
It multiplies each row index by its corresponding column index to select elements.

7. Analyze

Given x[np.ix_(rows, columns)] results in a selection of corner elements from x, what does this imply about rows and columns when x is a 4x3 matrix?

Rows and columns must be broadcastable to match the shape of x for corner selection.

Correct; np.ix_ uses broadcasting to create a meshgrid-like indexing scheme, allowing for the selection of corner or other specified elements.

Rows and columns must sum up to the dimensions of x.

Incorrect; the concept of summing indices is irrelevant to how np.ix_ functions.

Both rows and columns are required to be scalar values.
The np.ix_ function transforms rows and columns into a flat array.

Incorrect; np.ix_ does not flatten arrays but helps in broadcasting them for complex indexing.

8. Remember

What does the expression x[~np.isnan(x)] return when x is a NumPy array?

A boolean array indicating NaN positions in x

Incorrect; the negation of np.isnan(x) results in a boolean array used for indexing, not returned as output.

The indices of NaN values in x
All NaN values from x

Incorrect; the tilde (~) negates the boolean array created by np.isnan(x), thus excluding NaN values.

Non-NaN values from x

Correct; it returns all non-NaN values from x, filtering out the NaNs.

9. Understand

What is the result of x[x < 0] += 20 when x is a NumPy array containing negative values?

Creates a new array with values less than 0 increased by 20

Incorrect; the operation modifies the existing array x, not creating a new one.

Decreases all values in x by 20
Increases all negative values in x by 20

Correct; this expression adds 20 to all negative values in x, modifying them in place.

Sets all values in x to 20

10. Understand

How does NumPy treat boolean indexing when obj.ndim is less than x.ndim?

By ignoring the extra dimensions of x
By throwing an index error
By indexing x with obj followed by as many : as needed to match the rank of x

Correct; NumPy extends obj with : to match the dimensions of x, effectively filtering x across the dimensions where obj is True.

By automatically converting obj to match the dimensions of x

Incorrect; NumPy does not alter the dimensionality of obj but virtually extends it with :.

11. Apply

How would you filter x = np.array([[1, 2], [3, 4], [5, 6]]) to select rows where the first element is greater than 2?

x = np.array([[1, 2], [3, 4], [5, 6]])\nresult = x[:, x[0, :] > 2]

Incorrect; x[:, x[0, :] > 2] attempts to use a condition on the first row to index columns, which is not the stated goal.

x = np.array([[1, 2], [3, 4], [5, 6]])\nresult = x[x[:,0] > 2]

Correct; x[x[:,0] > 2] filters rows based on the condition applied to the first column.

x = np.array([[1, 2], [3, 4], [5, 6]])\nresult = x[:,0][x[:,0] > 2]

Incorrect; x[:,0][x[:,0] > 2] returns elements of the first column that meet the condition, not the rows.

x = np.array([[1, 2], [3, 4], [5, 6]])\nresult = x > 2

Incorrect; x > 2 returns a boolean array of the same shape as x, not filtered rows.

12. Apply

Given the following code snippet:

import numpy as np\nx = np.arange(10).reshape(2, 5)

How can you select elements greater than 4 using a boolean array?

result = x > 4\nprint(result)

Incorrect; x > 4 only generates a boolean array, not the filtered values.

result = x[x > 4]\nprint(result)

Correct; x[x > 4] uses boolean indexing to select elements of x that are greater than 4.

result = x[:, x > 4]\nprint(result)

Incorrect; x[:, x > 4] would incorrectly attempt to apply a boolean index to columns, mismatching dimensions.

result = x[np.where(x > 4)]\nprint(result)

Incorrect; np.where(x > 4) finds indices, but x[x > 4] is the direct method for value selection.

13. Analyze

What happens if you use a boolean index array b with b.ndim < x.ndim to index array x, and how does it affect the resulting array shape?

The resulting array will have the same dimensions as x.

Incorrect; the dimensions of the resulting array are affected by the number of True elements in b and the original dimensions of x.

An error is raised due to a dimension mismatch.
The resulting array is flattened to 1D, regardless of x's shape.

Incorrect; while boolean indexing can result in a flattened array, the shape is determined by the number of True values in b and the original shape of x, not always flattened.

Result shape: count of b's True elements, then x's dimensions.

Correct; the result is shaped by the number of True elements in b, with the rest of x's dimensions following. This is due to NumPy's broadcasting rules, extending b to match x's dimensions.

14. Analyze

Given a boolean array b of shape (2, 3) used to index a 3D array x of shape (2, 3, 5), resulting in a 2D array, what explains this behavior?

b reshapes x to match its dimensions before indexing.

Incorrect; b does not reshape x but selects elements according to the True positions in b.

The indexing operation fails but Python automatically corrects the shape.
The result is always a 2D array when using boolean indexing, regardless of x's dimensions.

Incorrect; the resulting array's dimensionality depends on the shapes of x and b, not a fixed outcome of using boolean indexing.

The boolean array b reduces dimensions by selecting rows in x's first two dimensions.

Correct; the boolean array selects elements based on its True values across the dimensions it matches with x, reducing the result's dimensionality to fit the number of True values in b and maintaining the last dimension of x.

15. Remember

What is the result of y[np.array([0, 2, 4]), 1:3] when y = np.arange(35).reshape(5,7)?

[[1, 2],\n [15, 16],\n [29, 30]]

[[1, 2, 3],\n [15, 16, 17],\n [29, 30, 31]]

[[0, 1, 2],\n [14, 15, 16],\n [28, 29, 30]]

[[2, 3],\n [16, 17],\n [30, 31]]

16. Understand

Why is using a slice (1:2) preferable to a single advanced index ([1]) when possible?

Slicing does not create a copy, maintaining the original array's memory layout.
Slicing can only be used with numeric data.
Advanced indexing provides more flexibility than slicing.
Advanced indexing is slower than slicing.

17. Apply

Given x = np.arange(60).reshape(3,4,5) and a boolean array mask = (x % 10 == 0), how would you select the elements divisible by 10 from the second row of each 2D subarray?

x[mask]

x[:, 1, :][mask[:, 1, :]]

Correct; applies the mask to the second row (1) of each 2D subarray, selecting elements divisible by 10.

x[:, 1][mask[:, 1]]

x[:, 1, mask[1, :, :]]

18. Apply

You have x = np.arange(100).reshape(10,10) and want to select the first, fifth, and ninth rows, but only columns three to seven. How do you accomplish this?

x[:, 3:8][np.array([0, 4, 8]), :]

x[[0, 4, 8]][:, 3:8]

x[3:8, np.array([0, 4, 8])]

x[np.array([0, 4, 8]), 3:8]

19. Analyze

Given an array x = np.random.rand(10,10,10) and indices ind1 = np.array([1, 3, 7]) and ind2 = np.array([0, 4, 6]) shaped (3,), why does x[:, ind1, ind2].shape result in (10, 3, 3) instead of (3, 10, 3)?

ind1 and ind2 can only index the first dimension.

Incorrect; ind1 and ind2 specifically index the second and third dimensions, not the first.

NumPy reshapes the result to the smallest possible dimensions.
Advanced indices modify last dimensions; slice : retains first dimension size.

Correct; advanced indexing applies to the dimensions indexed by ind1 and ind2, while the slice : keeps the size of the first dimension, leading to a result shape where the size of the indexed dimensions follows the original dimension sized by the slice.

The shape is determined by the order of indexing operations.

Incorrect; while the order affects the result's shape, the explanation does not accurately describe how the dimensions of ind1 and ind2 integrate into the resulting array.