Code Sample, a copy-pastable example if possible

python a=xr.DataArray(1.234) '{:1.3f}'.format(a) # throws error '{:1.3f}'.format(a.values) # behaves nicely

Problem description

I think it would be useful for repr(a) to return repr(a.values) when a.ndim==0 and perhaps also when a.size==1. For example, this would make such code work: python a=xr.DataArray(range(4)) ' '.join('{:d}'.format(v) for v in a) while currently one has to write python ' '.join('{:d}'.format(v.values) for v in a) I tried to think whether this will break something else but I couldn't think of anything.

closes #2084
a) plot.line can now accept also 'row' and 'col' keywords.
b) If 'hue' is passed as a keyword to DataArray.plot() it generates
   a line plot FacetGrid.
c) Line plots are automatically generated if the number of dimensions
   after faceting along row and/or col is one.

• [x] Closes #xxxx (remove if there is no corresponding issue, which should only be the case for minor changes)
• [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)

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

A very simple way to iterate over DataArrays, imitating numpy's flat iterator.

For a DataArray da, I implemented a flat iterator that works exactly like da.values.flat, but returns a singelton DataArray that has all the coordinates and meta data and whatnot.

I wrote it because I needed it for something and thought it would be useful for others too. I'd love to hear your opinions - if you think it's useful I'll write up some unittests.

When using Dataset.scatter with hue being a variable of dtype string, the legend turns out to be wrong.

MCVE Code Sample

python import xarray as xr import numpy as np dd = xr.Dataset({'y': (['x'], np.arange(8)), 'label': (['x'], list('AABBCCDD'))}, coords={'x': np.linspace(0,1,8)}) dd.plot.scatter(x='x', y='y', hue='label') Output is (note the legend):

Playing around it seems that it always chooses the first 4 values as the legend labels (note that the order of colors of the points is correct): python import xarray as xr import numpy as np dd = xr.Dataset({'y': (['x'], np.arange(8)), 'label': (['x'], list('ABBACDDC'))}, coords={'x': np.linspace(0,1,8)}) dd.plot.scatter(x='x', y='y', hue='label')

And if there are only 3 labels in total it chooses the first 3: python import xarray as xr import numpy as np dd = xr.Dataset({'y': (['x'], np.arange(6)), 'label': (['x'], list('ABBACC'))}, coords={'x': np.linspace(0,1,6)}) dd.plot.scatter(x='x', y='y', hue='label')

Expected Output

Legend in first two plots should read 'ABCD' and last plot 'ABC'

Versions

Fix typo in error message in plot.py

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

• [x] Closes #470
• [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
• [x] Add support for size?
• [x] Revert hue=datetime support bits

Say you have two variables in a Dataset and you want to make a scatter plot of one vs the other, possibly using different hues and/or faceting. This is useful if you want to inspect the data to see whether two variables have some underlying relationships between them that you might have missed. It's something that I found myself manually writing the code for quite a few times, so I thought it would be better to have it as a feature. I'm not sure if this is actually useful for other people, but I have the feeling that it probably is.

First, set up dataset with two variables:

```python import xarray as xr import numpy as np import matplotlib from matplotlib import pyplot as plt

A = xr.DataArray(np.zeros([3, 11, 4, 4]), dims=[ 'x', 'y', 'z', 'w'], coords=[np.arange(3), np.linspace(0,1,11), np.arange(4), 0.1np.random.randn(4)]) B = 0.1A.x2+A.y2.5+0.1A.zA.w A = -0.1*A.x+A.y/(5+A.z)+A.w ds = xr.Dataset({'A':A, 'B':B}) ds['w'] = ['one', 'two', 'three', 'five'] Now, we can plot all values of `A` vs all values of `B`:python plt.plot(A.values.flat,B.values.flat,'.') ```

What a mess. Wouldn't it be nice if you could color each point according to the value of some coordinate, say w? python ds.scatter(x='A',y='B', hue='w') Huh! There seems to be some underlying structure there. Can we also facet over a different coordinate? python ds.scatter(x='A',y='B',col='x', hue='w') or two coordinates? python ds.scatter(x='A',y='B',col='x', row='z', hue='w')

The logic is that dimensions that are not faceted/hue are just stacked using xr.stack and plotted. Only variables that have exactly the same dimensions are allowed.

Regarding implementation -- I am certainly not sure about the API and I probably haven't thought about edge cases with missing data or nans or whatnot, so any input would be welcome. Also, there might be a simpler implementation by first using to_array and then using existing line plot functions, but I couldn't find it.

Small typo.

just a small typo

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

I took a simple-minded strategy to fix: just mask and then rename the result to self.name. This is a slight overkill since the renaming will be done on every masking, not just on the edge cases when it's needed, but this is really a very small computational cost and it's much easier and bulletproof.

Code Sample, a copy-pastable example if possible

Consider the following 4 ways to mask an DataArray:

```python import xarray as xr

ds=xr.Dataset({'a': (['x'], range(10))}, coords={'x': range(10)}) ds['msk']=ds.a>5 msk=ds.a>5

v1=ds.a.where(ds.a>5) v2=ds.a.where(msk) v3=ds.where(ds.msk).a v4=ds.a.where(ds.msk)

', '.join(str(v.name) for v in (v1, v2, v3, v4))#output: 'a, a, a, None'

Problem description

All vs defined above are identical, except that v4 has lost its name in masking. This can cause errors in merging (like just happened to me and was hard and annoying to catch).

Is this behavior intentional? It seems inconsistent to me that ds.a.where(ds.msk) is not equivalent to ds.where(ds.msk).a

Expected Output

I would expect ds.a.where(ds.msk) to return a DataArray with the name a.

Output of xr.show_versions()

I'm trying to build the doc and it fails. I have a fresh miniconda install with a test environment created as instructed in the docs (i.e. conda env create -f ci/requirements-py36.yml followed by conda install -c conda-forge sphinx sphinx_rtd_theme sphinx-gallery numpydoc).

Code Sample, a copy-pastable example if possible

shell make clean make html

Problem description

It generates the following error:

Exception occurred: File "/Users/yohai/miniconda3/envs/test_env/lib/python3.6/site-packages/IPython/sphinxext/ipython_directive.py", line 567, in process_input raise RuntimeError('Non Expected exception in `{}` line {}'.format(filename, lineno)) RuntimeError: Non Expected exception in `/Users/yohai/Dropbox/Coding/xarray/doc/io.rst` line 376 The full traceback has been saved in /var/folders/mj/g9tnmysj6zld_3dg6hm9tkk00000gn/T/sphinx-err-8q55qmxi.log, if you want to report the issue to the developers. Please also report this if it was a user error, so that a better error message can be provided next time. A bug report can be filed in the tracker at <https://github.com/sphinx-doc/sphinx/issues>. Thanks! make: *** [html] Error 2

The problem seems to be in doc/io.rst. When I delete all lines upto line 367 it builds well The content of the traceback logfile:

Output of xr.show_versions()

• [x] Closes #2248 (remove if there is no corresponding issue, which should only be the case for minor changes)
• [x] Tests added (for all bug fixes or enhancements)
• [x] Tests passed (for all non-documentation changes)

Fixed a syntax inconsistency, allowing to pass unnamed arguments to faceted line plots.

Example code: ```python import xarray as xr import numpy as np

np.random.seed(0) da = xr.DataArray(np.random.randn(3, 3, 3, 3), dims=['x', 'y', 'z', 'w'], coords=[range(3), [3.5, 4.9, 6.7], ['a','b','c'], ['foo', 'bar', 'foobar']], name='arr_name') da.plot.line('o--',row='y', col='w',hue='z') ```

Closes #2295 (remove if there is no corresponding issue, which should only be the case for minor changes)

The link to the external blogpost about xarray and dask, that was fixed in https://github.com/pydata/xarray/pull/1573, is broken again. Is it available somewhere?

Code Sample, a copy-pastable example if possible

Unnamed arguments that are passed to line plots are directly passed to plot. ```python import xarray as xr import numpy as np

d3 = xr.DataArray(np.random.randn(10, 6, 3), dims=['x', 'y', 'z'], coords=[range(10), range(6), ['foo', 'bar', 'foobar']]) d2 = d3[..., 0].squeeze(drop=True)

This will make triangle markers and dashed lines:

d2.plot.line('^--',x='x') We [recently implemented ](https://github.com/pydata/xarray/pull/2107) faceted line plots:python d3.plot(col='z', hue='x') #should work from commit bc52f8a onwards. ```

However, current implementation does not allow for passing of unnamed arguments: python d3.plot('^--', col='z', hue='x') #gives error d3.plot.line('^--', col='z', hue='x') #gives different error I'd be happy to fix this (it's probably an easy fix, I didn't check) but I'm not sure what the correct user interface should be. Should DataArray.plot with hue as a keyword behave identically to DataArray.plot.line?

• [x] Closes #2248 (remove if there is no corresponding issue, which should only be the case for minor changes)
• [x] Tests added (for all bug fixes or enhancements)
• [x] Tests passed (for all non-documentation changes)

Fixed a syntax inconsistency, allowing to pass unnamed arguments to faceted line plots.

```python Example code: import xarray as xr import numpy as np

np.random.seed(0) da = xr.DataArray(np.random.randn(3, 3, 3, 3), dims=['x', 'y', 'z', 'w'], coords=[range(3), [3.5, 4.9, 6.7], ['a','b','c'], ['foo', 'bar', 'foobar']], name='arr_name') da.plot.line('o--',row='y', col='w',hue='z') ```

When data is more than 2 dimensional, plot() creates a FacetGrid where each facet gets plots two dimensional data. I would find it very useful to have similar functionality for line plots.

Let's define three DataArrays, of 2,3 and 4 dimensions, named d2, d3 and d4.

```python d4=xr.DataArray(np.random.randn(3,4,5,6), dims=['x','y','z','w'], coords=[range(3),range(4),range(5),range(6)]) d3=d4[...,0].drop('w') d2=d3[...,0].drop('z')

d4.plot(row='x', col='y') #creates a 2d facet grid, each facet is a pcolormesh d3.plot(col='x') #creates a 1d facet grid, each facet is a pcolormesh plt.show() ```

It would be very useful to have a similar interface for line plots too. That is, I would expect python d2.plot.line(row='y', x='x') to create a row of panels, each having one line. Similarly, I would expect ```python d3.plot.line(col='y', x='x')

or alternatively

d3.plot.line(col='y', hue='z') to create a row of panels, each having a series of lines, with `hue` corresponding to `z` and so forth. Finally,python d4.plot.line(row='z',col='y', x='x')

or alternatively

d4.plot.line(row='z',col='y', hue='w') `` should create a 2d matrix of panels, each having a series of lines, withhuecorresponding tow`.

This seems to me like a natural generalization of the behaviour of plot(), and I found myself coding manually loops to do that a few times.