This seems related to #326.

Code Sample, a copy-pastable example if possible

```python import numpy as np import xarray as xr

da = xr.DataArray(np.random.randint(0, 1, (10, 10, 3)), dims=['row', 'col', 'time'])

da.groupby('time').apply(np.linalg.norm) ```

Problem description

I would expect xarary to know how to apply generic numpy functions along specified axis. However, it currently raises the following exception:

```python

AttributeError Traceback (most recent call last) <ipython-input-22-5451ed1f09ee> in <module>() ----> 1 da.groupby('time').apply(np.linalg.norm)

~/anaconda3/lib/python3.7/site-packages/xarray/core/groupby.py in apply(self, func, shortcut, kwargs) 514 applied = (maybe_wrap_array(arr, func(arr, kwargs)) 515 for arr in grouped) --> 516 return self._combine(applied, shortcut=shortcut) 517 518 def _combine(self, applied, shortcut=False):

~/anaconda3/lib/python3.7/site-packages/xarray/core/groupby.py in _combine(self, applied, shortcut) 519 """Recombine the applied objects like the original.""" 520 applied_example, applied = peek_at(applied) --> 521 coord, dim, positions = self._infer_concat_args(applied_example) 522 if shortcut: 523 combined = self._concat_shortcut(applied, dim, positions)

~/anaconda3/lib/python3.7/site-packages/xarray/core/groupby.py in _infer_concat_args(self, applied_example) 289 290 def _infer_concat_args(self, applied_example): --> 291 if self._group_dim in applied_example.dims: 292 coord = self._group 293 positions = self._group_indices

AttributeError: 'numpy.float64' object has no attribute 'dims'

```

Expected Output

a data array whit a time coordinate of size 3 (ie same shape as da.groupby('time').mean())

Output of xr.show_versions()

I am running Ubuntu 16 with Xarray 0.9.1 on python 3.6.0.

I have found that any changes made to coordinates in a function that is called by a groupby object's apply method do not persist. The following code illustrates the problem:

```python import numpy as np import xarray as xr

def change_new_coord(dar): """ change the new_coord coord from 1 to 0 """ dar.coords['new_coord'] = 0 return dar

setup data array

data = np.ones((10, 10, 1000)) time = np.linspace(0, 10, 1000) coords = {'time': time, 'd2': range(10), 'd3': range(10)} dims = ['d2', 'd3', 'time'] dar = xr.DataArray(data, coords=coords, dims=dims)

attach coordinate based on d2 and d3

dar.coords['new_coord'] = (('d2', 'd3'), np.ones((10, 10)))

stack

stacked = dar.stack(z=('d2', 'd3'))

groupby

gr = stacked.groupby('z')

apply

out = gr.apply(change_new_coord).unstack('z')

raises; all values in new_coord should be 0, but they are still 1

assert np.all(out.coords['new_coord'] == 0) ```

I am using Ubuntu 16, python 3.6, and xarray 0.9.1

A DataArray can be stacked along one dimension, but when unstack is called a ValueError is raised. It seems that either unstack should work, or calling stack should also raise a ValueError.

```python import xarray as xr

dims = ['a', 'b'] coords = {'a': range(2), 'b':range(2)} values = [[0, 0], [0, 0]]

dar = xr.DataArray(values, coords, dims)

stacked = dar.stack(z=('a',)) # this works

unstack = stacked.unstack('z') # this raises ValueError

```

I am using Ubuntu 16, python 3.6, and xarray 0.9.1

Consider the following code: ```python import xarray as xr import numpy as np

dims = ['a', 'b'] coords = {'a': range(2), 'b':range(2), 'group': (('a', 'b'), [[0, 0], [0, 1]])} values = [[0, 0], [0, 0]]

dar = xr.DataArray(values, coords, dims)

dar[dict(group=0)] = 1 # group is only 0 for three of the four elements

expected_values = np.array([[1, 1], [1, 0]])

yet this raises because all four values are set to 1

assert np.all(np.isclose(dar.values, expected_values)) ```

I suspect trying to assign values in this way using a multi-dimensional coordinate should raise a ValueError as this does:

python dar[dict(group=0)]

I am using Ubuntu 16, python 3.6, and xarary 0.9.5.

```python import numpy as np import xarray as xr

setup for a simple grid

DX = 50 X = np.arange(0, 2010, DX) Y = np.arange(0, 2010, DX) Z = np.arange(0, 2010, DX) grid_shape = (len(X), len(Y), len(Z))

Create data array

dims = 'X Y Z'.split() coords = {'X': X, 'Y': Y, 'Z': Z} dar = xr.DataArray(np.ones(grid_shape), dims=dims, coords=coords)

slice the data array so that all Z values are greater than 1000

dar2 = dar.loc[dar.Z > 1000] assert np.all(dar2.Z > 1000) # fails becase dar is sliced along X, not Z ``` Since the object returned from dar.Z > 1000 is a data array with "Z" as the only dim I would expect this to slice the "Z" dim rather than X.

I am using: Ubuntu 16.04 python 3.6.0 xarray 0.9.1 scipy 0.18.1

The documentation states that if no path argument is passed to the to_netcdf method of the DataArray class it returns a bytes object. However, it returns None.

python import xarray as xr dar = xr.DataArray([1, 2, 3]) output = dar.to_netcdf() assert isinstance(output, bytes) # fails because output is None

It appears that the DataArray is not using the bottleneck move_var when calling var on a rolling object but it does for std. I have attached some simple benchmarks to demonstrate.

python version 3.6 pandas version 0.19.2 xarray version 0.9.1 bottleneck version 1.2.0

```python import numpy as np import xarray as xr import bottleneck import pandas as pd

data = np.random.rand(10000)

xarray setup

ar = xr.DataArray(data, dims=['time']) xrol = ar.rolling(time=30)

pandas setup

df = ar.to_pandas() prol = df.rolling(30) ```

```python

xray std profile

%time _ = xrol.std() ```

CPU times: user 0 ns, sys: 0 ns, total: 0 ns
Wall time: 209 µs

```python

xray var profile

%time _ = xrol.var() ```

CPU times: user 8.69 s, sys: 132 ms, total: 8.82 s
Wall time: 8.52 s

```python

pandas std profile

%time _ = prol.std() ```

CPU times: user 0 ns, sys: 0 ns, total: 0 ns
Wall time: 1.13 ms

```python

pandas var profile

%time _ = prol.var() ```

CPU times: user 0 ns, sys: 0 ns, total: 0 ns
Wall time: 617 µs

```python

bottleneck std profile

%time _ = bottleneck.move_std(data, 30) ```

CPU times: user 0 ns, sys: 0 ns, total: 0 ns
Wall time: 138 µs

```python

bottleneck var profile

%time _ = bottleneck.move_var(data, 30) ```

CPU times: user 0 ns, sys: 0 ns, total: 0 ns
Wall time: 143 µs

fixed a small type in the docs

• [ ] closes #xxxx
• [ ] tests added / passed
• [ ] passes git diff upstream/master | flake8 --diff
• [ ] whatsnew entry