Is your feature request related to a problem?

Currently, I have something similar to this, where the input_lat is transformed to new_lat (here, +0.25, but in real use case, it's indeterministic).

Since xarray_ufunc doesn't return a dataset with actual coordinates values, I had to return a second output to retain new_lat to properly update the coordinate values, but this second output is shaped time, lat, lon so I have to ds["lat"] = new_lat.isel(lon=0, time=0).values, which I think is inefficient; I simply need it to be shaped lat.

Any ideas on how I can modify this to make it more efficient?

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

air = xr.tutorial.open_dataset("air_temperature")["air"] input_lat = np.arange(20, 45)

def interp1d_np(data, base_lat, input_lat): new_lat = input_lat + 0.25 return np.interp(new_lat, base_lat, data), new_lat

ds, new_lat = xr.apply_ufunc( interp1d_np, # first the function air, air.lat, # as above input_lat, # as above input_core_dims=[["lat"], ["lat"], ["lat"]], # list with one entry per arg output_core_dims=[["lat"], ["lat"]], # returned data has one dimension exclude_dims=set(("lat",)), # dimensions allowed to change size. Must be a set! vectorize=True, # loop over non-core dims ) new_lat = new_lat.isel(lon=0, time=0).values ds["lat"] = new_lat ```

Describe the solution you'd like

Either be able to automatically assign the new_lat to the returned xarray object, or allow a 1D dataset to be returned

Describe alternatives you've considered

No response

Additional context

No response

The pixels seem stretched; https://xarray.pydata.org/en/stable/examples/multidimensional-coords.html

Would it be good to add a unique() method that mimics pandas?

import pandas as pd import xarray as xr pd.Series([0, 1, 1, 2]).unique() xr.DataArray([0, 1, 1, 2]).unique() # not implemented

Output: array([0, 1, 2]) AttributeError: 'DataArray' object has no attribute 'unique'

https://github.com/pydata/xarray/discussions/5865#discussioncomment-1636647

I wonder if it's possible to implement a built-in function like: da.str.format("%.2f") or xr.string_format(da, "%.2f)

To wrap: ``` import xarray as xr

da = xr.DataArray([5., 6., 7.]) das = xr.DataArray("%.2f") das.str % da

<xarray.DataArray (dim_0: 3)> array(['5.00', '6.00', '7.00'], dtype='<U4') Dimensions without coordinates: dim_0 ```

• [x] Closes #2795
• [x] Tests added
• [x] Passes pre-commit run --all-files
• [x] User visible changes (including notable bug fixes) are documented in whats-new.rst
• [x] New functions/methods are listed in api.rst

```python

numpy version

x = np.array([0, 1]) np.place(x, x == 0, 1)

pandas version

pd.Series([0, 1]).map({0: 1, 1: 1})

current workaround

ds = xr.Dataset({'test': [0, 1]}) np.place(ds['test'].values, ds['test'].values == 0, 1)

```

Problem description

Is there a built in method to map values like 0 to 1?

Expected Output

returns [1, 1]

If I have a ds with time, lat, lon and I call the same command twice: python ds.to_zarr('test.zarr', append_dim='time') ds.to_zarr('test.zarr', append_dim='time') Can it raise an error since all the times already exist?

Kind of like: ```python import numpy as np import xarray as xr

ds = xr.tutorial.open_dataset('air_temperature') ds.to_zarr('test_air.zarr', append_dim='time') ds_tmp = xr.open_mfdataset('test_air.zarr', engine='zarr') overlap = np.intersect1d(ds['time'], ds_tmp['time']) if len(overlap) > 1: raise ValueError(f'Found overlapping values in datasets {overlap}') ds.to_zarr('test_air.zarr', append_dim='time') ```

Ruined https://github.com/pydata/xarray/pull/5089 with reverting so remaking the PR for just dims

• [ ] Closes #xxxx
• [x] Tests added
• [x] Passes pre-commit run --all-files
• [x] User visible changes (including notable bug fixes) are documented in whats-new.rst
• [x] New functions/methods are listed in api.rst

Semi related to https://github.com/pydata/xarray/issues/2795, but not really; still want a separate unique function

• [ ] Closes #xxxx
• [x] Tests added
• [x] Passes pre-commit run --all-files
• [x] User visible changes (including notable bug fixes) are documented in whats-new.rst
• [x] New functions/methods are listed in api.rst

Not sure if exactly bug and what performance implications there are but it'd be more user friendly if supported:

1.) comparing against datetime python import datetime import pandas as pd import xarray as xr ds = xr.Dataset(coords={'int': [0, 1, 2]}) ds['data'] = ('int', [0, 5, 6]) ds.coords['time'] = ('int', pd.date_range('2017-02-01', '2017-02-03')) ds = ds.where(ds['time'] > datetime.datetime(2017, 2, 2)) ds

TypeError: '>' not supported between instances of 'int' and 'datetime.datetime'

2.) pd.Timestamp python import datetime import pandas as pd import xarray as xr ds = xr.Dataset(coords={'int': [0, 1, 2]}) ds['data'] = ('int', [0, 5, 6]) ds.coords['time'] = ('int', pd.date_range('2017-02-01', '2017-02-03')) ds = ds.where(ds['time'] > pd.to_datetime('2017-02-02')) ds

This works though when converting to np.datetime64 python import datetime import pandas as pd import xarray as xr ds = xr.Dataset(coords={'int': [0, 1, 2]}) ds['data'] = ('int', [0, 5, 6]) ds.coords['time'] = ('int', pd.date_range('2017-02-01', '2017-02-03')) ds = ds.where(ds['time'] > pd.to_datetime(['2017-02-02']).values) ds

Should rolling have a drop keyword, similar to squeeze(drop=True)? import xarray as xr air = xr.tutorial.open_dataset('air_temperature') air = air.rolling(time=7, drop=True).mean()

Equivalent: import xarray as xr air = xr.tutorial.open_dataset('air_temperature') air = air.rolling(time=7).mean() air = air.isel(time=slice(6, None))

Actual implementation will require considering min_period / center=True too

This works: import xarray as xr ds = xr.tutorial.open_dataset('air_temperature') ds.transpose('not_existing_dim', 'lat', 'lon', 'time', ...)

This doesn't (subset air): import xarray as xr ds = xr.tutorial.open_dataset('air_temperature') ds['air'].transpose('not_existing_dim', 'lat', 'lon', 'time', ...)

The error message is a bit inaccurate too since I do have Ellipsis included; might be related to two calls of: dims = tuple(utils.infix_dims(dims, self.dims)) ```

ValueError: ('not_existing_dim', 'lat', 'lon', 'time') must be a permuted list of ('time', 'lat', 'lon'), unless ... is included

Traceback ...

ValueError Traceback (most recent call last) <ipython-input-5-793dfc1507ea> in <module> 2 ds = xr.tutorial.open_dataset('air_temperature') 3 ds.transpose('not_existing_dim', 'lat', 'lon', 'time', ...) ----> 4 ds['air'].transpose('not_existing_dim', 'lat', 'lon', 'time', ...)

~/anaconda3/envs/py3/lib/python3.7/site-packages/xarray/core/dataarray.py in transpose(self, transpose_coords, dims) 2035 if dims: 2036 dims = tuple(utils.infix_dims(dims, self.dims)) -> 2037 variable = self.variable.transpose(dims) 2038 if transpose_coords: 2039 coords: Dict[Hashable, Variable] = {}

~/anaconda3/envs/py3/lib/python3.7/site-packages/xarray/core/variable.py in transpose(self, *dims) 1388 if len(dims) == 0: 1389 dims = self.dims[::-1] -> 1390 dims = tuple(infix_dims(dims, self.dims)) 1391 axes = self.get_axis_num(dims) 1392 if len(dims) < 2 or dims == self.dims:

~/anaconda3/envs/py3/lib/python3.7/site-packages/xarray/core/utils.py in infix_dims(dims_supplied, dims_all) 724 if set(dims_supplied) ^ set(dims_all): 725 raise ValueError( --> 726 f"{dims_supplied} must be a permuted list of {dims_all}, unless ... is included" 727 ) 728 yield from dims_supplied ```

import xarray as xr import pandas as pd xr.DataArray(pd.date_range('2020-01-01', '2020-02-01').tolist() + [pd.NaT]).ffill('dim_0')

<xarray.DataArray (dim_0: 33)> array(['2020-01-01T00:00:00.000000000', '2020-01-02T00:00:00.000000000', '2020-01-03T00:00:00.000000000', '2020-01-04T00:00:00.000000000', '2020-01-05T00:00:00.000000000', '2020-01-06T00:00:00.000000000', '2020-01-07T00:00:00.000000000', '2020-01-08T00:00:00.000000000', '2020-01-09T00:00:00.000000000', '2020-01-10T00:00:00.000000000', '2020-01-11T00:00:00.000000000', '2020-01-12T00:00:00.000000000', '2020-01-13T00:00:00.000000000', '2020-01-14T00:00:00.000000000', '2020-01-15T00:00:00.000000000', '2020-01-16T00:00:00.000000000', '2020-01-17T00:00:00.000000000', '2020-01-18T00:00:00.000000000', '2020-01-19T00:00:00.000000000', '2020-01-20T00:00:00.000000000', '2020-01-21T00:00:00.000000000', '2020-01-22T00:00:00.000000000', '2020-01-23T00:00:00.000000000', '2020-01-24T00:00:00.000000000', '2020-01-25T00:00:00.000000000', '2020-01-26T00:00:00.000000000', '2020-01-27T00:00:00.000000000', '2020-01-28T00:00:00.000000000', '2020-01-29T00:00:00.000000000', '2020-01-30T00:00:00.000000000', '2020-01-31T00:00:00.000000000', '2020-02-01T00:00:00.000000000', 'NaT'], dtype='datetime64[ns]') Dimensions without coordinates: dim_0

```

~/anaconda3/envs/py3/lib/python3.7/site-packages/xarray/core/computation.py in apply_variable_ufunc(func, signature, exclude_dims, dask, output_dtypes, vectorize, keep_attrs, dask_gufunc_kwargs, args) 698 ) 699 --> 700 result_data = func(input_data) 701 702 if signature.num_outputs == 1:

~/anaconda3/envs/py3/lib/python3.7/site-packages/bottleneck/slow/nonreduce_axis.py in push(a, n, axis) 49 elif ndim == 0: 50 return y ---> 51 fidx = ~np.isnan(y) 52 recent = np.empty(y.shape[:-1]) 53 count = np.empty(y.shape[:-1])

TypeError: ufunc 'isnan' not supported for the input types, and the inputs could not be safely coerced to any supported types according to the casting rule ''safe'' ```

I want to do something similar as xesmf's weighted regridding, but without the need to install esmpy which has a lot of dependencies.

Are variations of the following possible? ds.weighted(coslat_weights).coarsen(lat=2, lon=2).mean()

ds.coarsen(lat=2, lon=2).weighted(coslat_weights).mean()

Currently, it shows nanoseconds. import xarray as xr ds = xr.tutorial.open_dataset('air_temperature') ds.coords['tau'] = ds['time'] - ds['time'][0] ds.mean(['lat', 'lon'])['air'].swap_dims({'time': 'tau'}).plot()

If I have two datasets and I want to match the lat/lon, but not the time, I would have to do ds1.interp(lat=ds2['lat'], lon=ds2['lon']) would be nice if I could do ds1.interp_like(ds2, exclude_dims=['time'])

MCVE Code Sample

Since this code crashes for me and I don't have xarray master, I can't create a tested MCVE Code sample at the moment, but I think something along the lines of: python import xarray as xr ds = xr.Dataset(coords={'time': xr.cftime_range(start='2000', periods=6, freq='2MS', calendar='noleap'), 'something': [0, 1, 2, 3]}) print(ds.indexes['time']) ds = ds.rename({'something': 'something_else'}) print(ds.indexes['time'])

Expected Output

CFTimeIndex([2000-05-01 12:00:00, 2000-05-02 12:00:00, ... 2001-04-01 12:00:00], dtype='object', name='time', length=425) After renaming Index([2000-05-01 12:00:00, 2000-05-02 12:00:00, ... 2001-04-01 12:00:00], dtype='object', name='time', length=425)

Problem Description

CFTimeIndex changes to normal Index after renaming

Output of xr.show_versions()

MCVE Code Sample

python import xarray as xr xr.cftime_range(start='2000', periods=6, freq='2MS', calendar='noleap')

Expected Output

The output from the example

Problem Description

```

ValueError Traceback (most recent call last) <ipython-input-3-4ff834de4bd2> in <module> 1 import xarray as xr ----> 2 xr.cftime_range(start='2000', periods=6, freq='2MS', calendar='noleap')

~/anaconda3/envs/py3/lib/python3.7/site-packages/xarray/coding/cftime_offsets.py in cftime_range(start, end, periods, freq, normalize, name, closed, calendar) 961 962 if start is not None: --> 963 start = to_cftime_datetime(start, calendar) 964 start = _maybe_normalize_date(start, normalize) 965 if end is not None:

~/anaconda3/envs/py3/lib/python3.7/site-packages/xarray/coding/cftime_offsets.py in to_cftime_datetime(date_str_or_date, calendar) 677 "a calendar type must be provided" 678 ) --> 679 date, _ = _parse_iso8601_with_reso(get_date_type(calendar), date_str_or_date) 680 return date 681 elif isinstance(date_str_or_date, cftime.datetime):

~/anaconda3/envs/py3/lib/python3.7/site-packages/xarray/coding/cftimeindex.py in _parse_iso8601_with_reso(date_type, timestr) 114 # 1.0.3.4. 115 replace["dayofwk"] = -1 --> 116 return default.replace(**replace), resolution 117 118

cftime/_cftime.pyx in cftime._cftime.datetime.replace()

ValueError: Replacing the dayofyr or dayofwk of a datetime is not supported. ```

Output of xr.show_versions()

```python import xarray as xr import matplotlib.pyplot as plt

ds = xr.tutorial.open_dataset('air_temperature')['air'].isel(time=0) ```

This works as expected python ax = plt.axes() ds.plot(x='lon', y='lat', ax=ax) ax.set_title('new_title')

This doesn't ax = plt.axes() ds.plot(x='lon', y='lat', ax=ax) ax.set_title('new_title', loc='left')

With non-default loc, the old title still shows

Is there a more intuitive, built-in way of substituting values based on the conditions without having to flip every logic operator?

``` import xarray as xr ds = xr.tutorial.open_dataset('air_temperature') ds['text'] = (('time', 'lat', 'lon'), np.zeros_like(ds['air'].values).astype(str))

ds['text'] = ds['text'].where(ds['air'] < 273, 'above freezing') ds['text'] = ds['text'].where(ds['air'] > 273, 'below freezing') ds['text'] = ds['text'].where(ds['air'] != 273, 'freezing')

ds.hvplot('lon', 'lat', z='air', hover_cols=['text']).opts(color_levels=[200, 273, 300]) ```

The numpy equivalent (also seems faster by 2x) ``` above_freezing = np.where(ds['air'].values > 273) ds['text'].data[above_freezing] = 'above_freezing'

below_freezing = np.where(ds['air'].values < 273) ds['text'].data[below_freezing] = 'below_freezing'

freezing = np.where(ds['air'].values == 273) ds['text'].data[freezing] = 'freezing' ```

• [x] Closes #1875
• [x] Tests added (for all bug fixes or enhancements)
• [x] Tests passed (for all non-documentation changes)
• [x] Fully documented, including whats-new.rst for all changes and api.rst for new API (remove if this change should not be visible to users, e.g., if it is an internal clean-up, or if this is part of a larger project that will be documented later)

Will add the others stuff from the checklist soon.