To make things concrete, the solution that I have in mind is as simple as adding this function to DataArray:

python def __format__(self, format_spec): return self.values.__format__(format_spec)

Here's one use case I have encountered: python ds=xr.Dataset({'A':(['x','y','z'], np.random.rand(40,40,3)), 'B':(['z'], np.random.randn(3))}, coords={'z':[31,42,45]}) fg=ds.A.plot(col='z') for ax, d in zip(fg.axes.flat, fg.name_dicts.flat): t=ax.get_title() ax.set_title('{} and B(z)={:1.2}'.format(t, ds.sel(**d).B))

This way, if you want to vectorize a __format__ on an array can you not simply do ```python ar = xr.DataArray([39, 103, id(xr)]) print('{:3.3f} {:3.3e} {:x}'.format(*ar))

prints 39.000 1.030e+02 10e5bb548

```

I tend towards the former, to coerce singleton arrays to behave as scalars of their dytpe. I think it makes more sense in terms of use cases (at least everything that I needed). I don't mind implementing it if there is agreement as to which of the two to do.

These behaviors would definitely conflict for scalar objects -- in the second case, we would still want to include some indication that it's an xarray.DataArray. NumPy doesn't have a conflict because indexing an array results in a NumPy scalars, which prints like Python builtin scalars.

@shoyer I don't see why would that be the case. If I format something as '{:04d} {:3.5e} {:2.3E}'.format(dataarray) or whatnot, I would expect that the average user would expect to get '0043 4.35000e+02 2.450E+02' in return, without any indication that these are data arrays.

@yohai , sorry, I misunderstood __format__ and __repr__. I like shoyer's

vectorize format() over each element of the array (the proposal in the linked numpy issue)

as I feel it more consistent with the existing xarray __repr__.

I sometimes want a 0d-dataarray to behave as a native scalar. format is one of a typical case, but there are several other cases, e.g., np.ones(xr.DataArray([0])[0]). Therefore, I always needs to be carefule whether the scalar is xarray object or not.

I am a bit worrying if printing 0d-dataarray as a scalar would confuse me as it is a scalar not a 0d-array.

Here's a related NumPy issue: https://github.com/numpy/numpy/issues/5543

I guess there are two possible behaviors for '{:d}'.format(x) where x is a DataArray object: - coerce scalar arrays to native Python numbers and format it like a float - vectorize format() over each element of the array (the proposal in the linked numpy issue)

These behaviors would definitely conflict for scalar objects -- in the second case, we would still want to include some indication that it's an xarray.DataArray. NumPy doesn't have a conflict because indexing an array results in a NumPy scalars, which prints like Python builtin scalars.

On the one hand I agree, but note that the same behavior works for numpy arrays

```python import numpy as np a=np.array([1,2,3,4]) ' '.join('{:d}'.format(v) for v in a)

prints '1 2 3 4'

```

I agree that it is a bit annoying that 1d DataArray prints much information especially we want to embed the value into a string. However, I'm a bit worried whether it would be surprising if an object that looks a native scalar is actually an xr.DataArray of one element, especially when working in an interactive environment.

Yes, I think this would be a nice addition. This would entail implementing a __format__ method on xarray.DataArray: https://docs.python.org/3/reference/datamodel.html#object.format