issues

What happened:

Defining the kwargs used in xr.apply_ufunc in a separate dictionary and using it multiple times in different call of the method, while using dask="paralellized", ends in an error since the dimension names in ouput_sizes (inside dask_gufunc_kwargs) are modified internally.

What you expected to happen:

Keep the same dictionary of kwargs unmodified

Minimal Complete Verifiable Example:

```python import numpy as np

import xarray as xr

def dummy1(data, nfft): return data[..., (nfft // 2) + 1 :] * 2

def dummy2(data, nfft): return data[..., (nfft // 2) + 1 :] / 2

def xoperations(xarr, **kwargs): ufunc_kwargs = dict( kwargs=kwargs, input_core_dims=[["time"]], output_core_dims=[["freq"]], dask="parallelized", output_dtypes=[np.float], dask_gufunc_kwargs=dict(output_sizes={"freq": int(kwargs["nfft"] / 2) + 1}), )

ans1 = xr.apply_ufunc(dummy1, xarr, **ufunc_kwargs)
ans2 = xr.apply_ufunc(dummy2, xarr, **ufunc_kwargs)

return ans1, ans2

test = xr.DataArray( 4, coords=[("time", np.arange(1000)), ("lon", np.arange(160, 300, 10))] ).chunk({"time": -1, "lon": 10})

xoperations(test, nfft=1024) ```

This returns

```

ValueError Traceback (most recent call last) <ipython-input-1-822bd3b2d4da> in <module> 32 ).chunk({"time": -1, "lon": 10}) 33 ---> 34 xoperations(test, nfft=1024)

<ipython-input-1-822bd3b2d4da> in xoperations(xarr, kwargs) 23 24 ans1 = xr.apply_ufunc(dummy1, xarr, ufunc_kwargs) ---> 25 ans2 = xr.apply_ufunc(dummy2, xarr, **ufunc_kwargs) 26 27 return ans1, ans2

~/GitLab/xarray_test/xarray/xarray/core/computation.py in apply_ufunc(func, input_core_dims, output_core_dims, exclude_dims, vectorize, join, dataset_join, dataset_fill_value, keep_attrs, kwargs, dask, output_dtypes, output_sizes, meta, dask_gufunc_kwargs, *args) 1086 join=join, 1087 exclude_dims=exclude_dims, -> 1088 keep_attrs=keep_attrs, 1089 ) 1090 # feed Variables directly through apply_variable_ufunc

~/GitLab/xarray_test/xarray/xarray/core/computation.py in apply_dataarray_vfunc(func, signature, join, exclude_dims, keep_attrs, args) 260 261 data_vars = [getattr(a, "variable", a) for a in args] --> 262 result_var = func(data_vars) 263 264 if signature.num_outputs > 1:

~/GitLab/xarray_test/xarray/xarray/core/computation.py in apply_variable_ufunc(func, signature, exclude_dims, dask, output_dtypes, vectorize, keep_attrs, dask_gufunc_kwargs, *args) 632 if key not in signature.all_output_core_dims: 633 raise ValueError( --> 634 f"dimension '{key}' in 'output_sizes' must correspond to output_core_dims" 635 ) 636 output_sizes_renamed[signature.dims_map[key]] = value

ValueError: dimension 'dim0' in 'output_sizes' must correspond to output_core_dims ```

It is easily verifiable by sneaking a print statement before and after calling the first apply_ufunc. Everything is the same but the dimension names in output_sizes

```python {'kwargs': {'nfft': 1024}, 'input_core_dims': [['time']], 'output_core_dims': [['freq']], 'dask': 'parallelized', 'output_dtypes': [<class 'float'>], 'dask_gufunc_kwargs': {'output_sizes': {'freq': 513}}} {'kwargs': {'nfft': 1024}, 'input_core_dims': [['time']], 'output_core_dims': [['freq']], 'dask': 'parallelized', 'output_dtypes': [<class 'float'>], 'dask_gufunc_kwargs': {'output_sizes': {'dim0': 513}}}

```

Anything else we need to know?:

I have a fork with a fix ready to be sent as a PR. I just imported the copy module and used deepcopy like this

python dask_gufunc_kwargs = copy.deepcopy(dask_gufunc_kwargs) around here

https://github.com/pydata/xarray/blob/2acd0fc6563c3ad57f16e6ee804d592969419938/xarray/core/computation.py#L1013-L1020

If it's good enough then I can send the PR.

Environment:

• [x] Closes #4399
• [ ] Tests added
• [x] Passes isort . && black . && mypy . && flake8
• [ ] User visible changes (including notable bug fixes) are documented in whats-new.rst
• [ ] New functions/methods are listed in api.rst

Following the suggestion of @kmuehlbauer, I am using just a shallow copy since a deep one is not required.

Really minor docstring fixes, just added 's' at the end of kwarg and deleted Default n = 5 from thin method's docstring since it doesn't have a default value.

Seems like I forgot to point head, tail and thin to the right direction in the DataArray api documentation

Related #3278 This PR makes the methods head, thin and tail for both DataArray and Dataset accept a single integer value as a parameter. If no parameter is given, then it defaults to 5. - [x] Tests added - [x] Passes black . && mypy . && flake8

I feel like there's room for improvement in the docstrings, any change or suggestion is welcome!

• [x] Closes #319
• [x] Tests added
• [x] Passes black . && mypy . && flake8
• [x] Fully documented, including whats-new.rst for all changes and api.rst for new API

As explained here https://github.com/pydata/xarray/pull/3159#discussion_r316230281 , when a user uses a scalar array to build a DataArray with coords given as a dictionary the error is not self explanatory. ```python

xr.DataArray(np.array(1), coords={'x': np.arange(4), 'y': 'a'}, dims=['x']) ... KeyError: 'x' ```

This PR makes sure that when data is a scalar array and dims is not empty, it sets the shape to (0,) to make it fail with the proper raise message

```python

xr.DataArray(np.array(1), coords={'x': np.arange(4), 'y': 'a'}, dims=['x']) ... ValueError: conflicting sizes for dimension 'x': length 0 on the data but length 4 on coordinate 'x' ```

• [x] Test updated
• [x] Passes black . && mypy . && flake8
• [ ] Fully documented, including whats-new.rst for all changes and api.rst for new API (is this needed for a change like this?)

I attempted to implement what has been asked for in #277 as an effort to contribute to this project. This PR adds the ability to initialize a DataArray with a constant value, including np.nan. Also, if data = None then it is initialized as np.empty to take advantage of its speed for big arrays. ```python

foo = xr.DataArray(None, coords=[range(3), range(4)]) foo <xarray.DataArray (dim_0: 3, dim_1: 4)> array([[4.673257e-310, 0.000000e+000, 0.000000e+000, 0.000000e+000], [0.000000e+000, 0.000000e+000, 0.000000e+000, 0.000000e+000], [0.000000e+000, 0.000000e+000, 0.000000e+000, 0.000000e+000]]) Coordinates: * dim_0 (dim_0) int64 0 1 2 * dim_1 (dim_1) int64 0 1 2 3 ```

• [x] Closes #878, #277
• [x] Tests added
• [x] Fully documented, including whats-new.rst for all changes and api.rst for new API

Regarding the tests, I am not sure how to test the creation of an empty DataArray with data=None since the values changes between calls of np.empty. This is the reason I only added the test for the constant value.