issue_comments

After seeing the discussion in #680, I'm wondering if showing the firsts values of the flattened array wouldn't be enough here, e.g., something like this:

```

d <xarray.DataArray (a: 2, b: 5, c: 2, d: 10)> array int64 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 ... Coordinates: * a (a) <U1 'A' 'B' * b (b) <U5 'Cat 1' 'Cat 2' 'Cat 3' 'Cat 4' 'Cat 5' * c (c) <U1 'J' 'K' * d (d) int64 0 1 2 3 4 5 6 7 8 9 ```

This example is more consistent with the repr of Dataset data variables, and similarly we could customize the repr of dask arrays and lazy arrays (loaded from netcdf files) like this:

```

d.chunk((10, 5, 5, 10)) <xarray.DataArray (a: 2, b: 5, c: 2, d: 10)> dask.array int64 chunksize=(10, 5, 5, 10) Coordinates: * a (a) <U1 'A' 'B' * b (b) <U5 'Cat 1' 'Cat 2' 'Cat 3' 'Cat 4' 'Cat 5' * c (c) <U1 'J' 'K' * d (d) int64 0 1 2 3 4 5 6 7 8 9 ```

```

d.name = 'myvar' d.to_netcdf('data.nc') xr.open_dataset('data.nc').myvar <xarray.DataArray 'myvar' (a: 2, b: 5, c: 2, d: 10)> lazy-array int64 Coordinates: * a (a) <U1 'A' 'B' * b (b) <U5 'Cat 1' 'Cat 2' 'Cat 3' 'Cat 4' 'Cat 5' * c (c) <U1 'J' 'K' * d (d) int64 0 1 2 3 4 5 6 7 8 9 ```

In most cases I found the DataArray repr useful for quickly checking the dimensions (both names and sizes), the attributes and the types/values of both data and labels (I mean just checking here if the values are consistent regarding their units, acceptable ranges, etc.), but rarely for in-depth checking of the data values along each dimension, hence my suggestion of a flat (subset) array.

To inspect the data of high dimensional datarrays, I've mainly used the indexing logic of xarray to extract slices of <3 dimensions. However, I admit that for quick inspection purposes I actually like your suggestion of having a specific repr method that would allow showing small data slices as labeled tables, especially if we choose to always use a flat array for the repr of Dataarray (i.e., even when the number of dimensions <3). Why not something like:

``` python

d.slice_repr(a=0, b=0) d 0 1 2 3 4 5 6 7 8 9 c
J 0 1 2 3 4 5 6 7 8 9 K 10 11 12 13 14 15 16 17 18 19 ```

This is equivalent to

``` python

dslice = d.isel(a=0, b=0) pd.DataFrame(data=dslice.data, index=dslice.c, columns=dslice.d) ```

Except that slice_repr() would return a string instead of a data object (or an array or a dataframe). Not sure about the name and/or signature of slice_repr(), though.

There could be some display options exposed to manage this - for instance I personally would not like a flat array - but see how it could make sense.

Additionally / alternatively, the repr I'm talking (small slice of values laid out with coordinate labels) could called something other than __repr__ - something like pandas .head() although may be a better name to use here.

I agree, but I see one or two cases where it could be useful to have the first few values for each dim. For example with geopotential data on pressure levels, it could be interesting to see how the data varies with height on the third dim. But this is a detail, not very important.

I think dupe of https://github.com/pydata/xarray/issues/680

Good idea! I am in favor of as few repr as possible, i.e. maybe the first few values in each dimension.

Agreed, I'm never been really happy with our use of the NumPy repr for >2 dimensions. It's quite hard to match up the labels.

Something like this would be a meaningful improvement! I would encourage experimentation on this.