7

numpy arrays can be partially assigned using integer or boolean indices like this:

import numpy as np
x = np.arange(5)
x[[2,4]]=0
x
## array([0., 0., 1., 0., 1.])
x[[True]*2+[False]*3]=2
x
## array([2., 2., 1., 0., 1.])

However, even though x[[2,4]] is in lvalue in this context, the lvalue cannot be assigned to another variable, because in this case the assignment is done by __setitem__, whereas __getitem__, when passed an integer or boolean list, creates a copy:

x = np.arange(5)
y = x[[2,4]]
y[:] = 1
x
array([0., 0., 0., 0., 0.])

Question: is there any simple/clean way to get a writeable array view based on an integer-indexed or boolean-indexed index subset? By "simple/clean" I mean that I want to avoid writing a new class, or keeping track of the sub-indices myself. Basically I'm looking for some numpy function or trick that I haven't been able to google.

The point of this question is to be able to do this recursively, to be able to create functions that assign to pieces of an array by just passing views of the array around, rather than passing indices as well as the base array.

Improve this question
1
  • Basically the amount of information the you want to pass is more than what the view model can handle. Commented Oct 18, 2019 at 15:39

2 Answers 2

Reset to default
2

A nice explanation to your question here:

You can create views by selecting a slice of the original array, or also by changing the dtype (or a combination of both). The rule of thumb for creating a slice view is that the viewed elements can be addressed with offsets, strides, and counts in the original array. (...)

The reason why a fancy indexing is not returning a view is that, in general, it cannot be expressed as a slice (in the sense stated above of being able to be addressed with offsets, strides, and counts).

For example, fancy indexing for could have been expressed by , but it is not possible to do the same for by means of a slice. So, this is why an object with a copy of the original data is returned instead.

So as a general rule, no, you can't.

In my opinion the most "numpy" way of working with views is by working with masks, and keeping track of these instead of assigning the views to a new variable. I'd simply do:

m = [2, 4]
x[m] = some_function(x[m]) # whatever you need to do
Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

Thanks, yeah, it looks like there's no way to do what I want naturally. The problem with f(x[m]) is that it copies x[m], which in recursive functions can lead to a lot of copying, particularly if x is 2d, in which case copying x[m] is a lot more expensive than copying just m. Writing the function as f(x,m) avoids the copying, but is less clean.
2

Question: is there any simple/clean way to get a writeable array view based on an integer-indexed or boolean-indexed index subset?

No.

NumPy arrays (and views) are required to have constant strides (i.e., the distance between elements in memory has to be constant). If your indexing operation would create an object that violates this limitation, you are out of luck.

See e.g. here for a discussion of a related problem:

You cannot in the numpy memory model. The numpy memory model defines an array as something that has regular strides to jump from an element to the next one.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.