ENH: Apply numpy function to named axes

[max-sixty]

I'm currently transitioning sequences of pandas Panels over to xray Datasets. Part of our process applies a set of functions to Panels; for example:

panel = panel.apply(lambda x: x.rank(ascending=False), axis=(1, 2))
df = np.nanpercentile(panel, q=75, axis=2)

One of the benefits of xray is the clarity that comes from named axes. Is there a way of applying a function over named axes?
For example:

result = data_array.apply(np.argsort, axis=('Risk', 'Dates'))
result = data_array.apply(np.nanpercentile, axis='Dates')

[shoyer]

Yes, use the reduce method -- which should probably be called something more appropriately generic such as aggregate given that it doesn't only do reduces, e.g.,

In [5]: data_array = xray.DataArray(np.random.randn(3, 4, 5), dims=['x', 'y', 'z'])

In [14]: data_array.reduce(np.nanpercentile, q=95, dim=['x', 'y'])
Out[14]:
<xray.DataArray (z: 5)>
array([ 1.79306097,  0.9788271 ,  0.9385694 ,  1.30198262,  1.78693993])
Coordinates:
  * z        (z) int64 0 1 2 3 4

To apply an operation along an axis that doesn't do an aggregation, you can use the get_axis_num, e.g.,

In [27]: xray.DataArray(np.argsort(data_array, axis=data_array.get_axis_num('x')), data_array.coords)
Out[27]:
<xray.DataArray (x: 3, y: 4, z: 5)>
array([[[2, 1, 1, 2, 0],
        [0, 2, 2, 1, 0],
        [1, 1, 2, 1, 0],
        [2, 0, 0, 0, 0]],

       [[1, 2, 2, 0, 2],
        [2, 1, 1, 0, 1],
        [2, 0, 1, 0, 2],
        [1, 1, 2, 2, 1]],

       [[0, 0, 0, 1, 1],
        [1, 0, 0, 2, 2],
        [0, 2, 0, 2, 1],
        [0, 2, 1, 1, 2]]])
Coordinates:
  * x        (x) int64 0 1 2
  * y        (y) int64 0 1 2 3
  * z        (z) int64 0 1 2 3 4

We don't currently have a convenience method for the later but that might be good idea. I'm not entirely sure if it should be called DataArray.apply, but it could reuse maybe_wrap_array from Dataset.apply and add auto-conversion from dim to axis arguments

[max-sixty]

Wonderful, thanks @shoyer.

FWIW, reduce doesn't seem well documented. It also looks very similar to apply from pandas, albeit with the requirement (rather than the option) to lose a dimension.

I also found .groupby('x').apply(func), which I think is broadly equivalent to a pandas .apply(func, axis=0).

Closing for now, cheers.