Mixed advanced and basic indexing in NumPy: restructure for views or accept the copy?

Resolution

To achieve view semantics in NumPy 2.x, restructuring into pure basic slicing is the only documented and safe option. Advanced indexing—which includes any combination of integer arrays or boolean masks, even when mixed with slices—fundamentally returns a copy because arbitrary index selections cannot be represented by the stride-based memory layout of a NumPy view.

Implementation Guidance

If you require in-place updates or zero-copy behavior, choose one of the following paths based on your data access pattern:

• For regular intervals: Replace integer arrays with slice() objects or the start:stop:step syntax.
• For irregular selections: If you need to modify the original array, avoid assigning the result to a variable. Instead, perform the operation directly on the original array using the advanced index (e.g., arr[indices, slice] = value). This triggers indexed assignment, which writes directly to the source memory.
• For complex windowing: Use np.lib.stride_tricks.sliding_window_view if your access pattern follows a sliding window, as this provides a view without the risks of raw as_strided.

Analysis of Design Trade-offs

Using np.shares_memory() as a Guard
Using np.shares_memory() in your test suite is a reasonable and standard practice. Because the boundary between basic and advanced indexing is deterministic, these checks are not fragile. For higher confidence in critical paths, you can also assert that result.base is arr, which explicitly verifies that the result is a view of the original array.

Stability of the Copy Contract
In NumPy 2.x, you can treat the copy behavior of advanced indexing as a guaranteed contract. Changing this would introduce massive backward-incompatibility across the entire scientific Python ecosystem. While NumPy rarely provides formal "forever" guarantees, this specific behavior is a core architectural pillar of the ndarray.

Verification

You can verify the copy behavior of your specific mixed pattern with this scoped check:

import numpy as np

# Setup
arr = np.arange(24).reshape(4, 6)
# Mixed indexing: integer array + slice
result = arr[[0, 2], 1:3]

# Verification
print(f"Shares memory: {np.shares_memory(arr, result)}") # Expected: False
print(f"Has base: {result.base is not None}")            # Expected: False (it is its own base)

Missing Diagnostic: To determine if restructuring is strictly necessary for your performance budget, what is the typical cardinality of your integer index arrays relative to the total array size?