The model of how indexing with non-DataArray objects is described here under vectorized indexing: “Slices or sequences/arrays without named-dimensions are treated as if they have the same dimension which is indexed along”

For better or worse, xarray doesn’t have any way to distinguish between “meaningful” and “default” dimension names. This means that a DataArray without explicitly named dimensions will indeed broadcast differently (e.g., in either arithmetic or indexing) than unlabeled NumPy arrays.

These were intentional design choices: we like our name based broadcasting rules better than NumPy’s positional rules. And for the most part, the default dimension names like dim_0 are just there so a user can see how they need to change their data instead of getting an error message.

Thanks for the clear question.

Having array and xr.DataArray(array) behave differently as arguments is (fairly) rare, so I can understand that it might be surprising at first.

One advantage of this is it allowing pointwise indexing over a new dimension. Generally that would be a usefully named dimension (e.g. z in the docs), rather than dim_0 though...

I'll defer to @shoyer on commenting on his design choices if he sees this thread

I do think it's complicated though (I find myself re-reading the docs and trying to remember how it works depending on the type & order of the arguments!), and a nicely presented table with the possible indexing methods and their results would be great.

Why do DataArrays have different behavior than other array-likes for these methods?

For sel and isel. What the reasoning for making these statements behave differently?

```python xidx = np.array([1, 2, 3]) yidx = np.array([1, 2, 3])

da.isel(x=xidx, y=yidx)

<xarray.DataArray (x: 3, y: 3)>

array([[ 9, 10, 11],

[17, 18, 19],

[25, 26, 27]])

Coordinates:

* x (x) <U1 'b' 'c' 'd'

* y (y) int64 10 20 30

da.isel(x=xr.DataArray(xidx), y=xr.DataArray(yidx))

<xarray.DataArray (dim_0: 3)>

array([ 9, 18, 27])

Coordinates:

x (dim_0) <U1 'b' 'c' 'd'

y (dim_0) int64 10 20 30

Dimensions without coordinates: dim_0

```

Why do DataArrays have different behavior than other array-likes for these methods?

Could you expand a bit? Do you mean re sel etc rather than positional indexing?

The documentation for what you want is here: https://xarray.pydata.org/en/stable/indexing.html#more-advanced-indexing. Basically you need to provide DataArrays with a new dimension instead of lists.

Thanks! I must have missed this, I suspect since my use was actually setting the values at some coordinates. Is there an efficient way to do that?

I'd be happy to add some notes to the documentation about that. The .sel and isel methods could definitely use longer doc strings. It would be useful to have a better understanding of the concept this implements though. Why do DataArrays have different behavior than other array-likes for these methods?

The documentation for what you want is here: https://xarray.pydata.org/en/stable/indexing.html#more-advanced-indexing. Basically you need to provide DataArrays with a new dimension instead of lists.

PRs to improve the documentation are very welcome (ref https://github.com/pydata/xarray/issues/1552). We actually have a nice schematic here: https://xarray.pydata.org/en/stable/interpolation.html#advanced-interpolation