│ │ │ │ │
│ │ │ │ │ In [6]: import zarr
│ │ │ │ │
│ │ │ │ │ In [7]: zgroup = zarr.open("rasm.zarr")
│ │ │ │ │
│ │ │ │ │ In [8]: print(zgroup.tree())
│ │ │ │ │ /
│ │ │ ├── ./usr/share/doc/python-xarray-doc/html/interpolation.html
│ │ │ │ @@ -408,24 +408,24 @@
│ │ │ │ ....: np.sin(np.linspace(0, 2 * np.pi, 10)),
│ │ │ │ ....: dims="x",
│ │ │ │ ....: coords={"x": np.linspace(0, 1, 10)},
│ │ │ │ ....: )
│ │ │ │ ....:
│ │ │ │
│ │ │ │ In [17]: da.plot.line("o", label="original")
│ │ │ │ -Out[17]: [<matplotlib.lines.Line2D at 0xe55b8b68>]
│ │ │ │ +Out[17]: [<matplotlib.lines.Line2D at 0xa8148eb0>]
│ │ │ │
│ │ │ │ In [18]: da.interp(x=np.linspace(0, 1, 100)).plot.line(label="linear (default)")
│ │ │ │ -Out[18]: [<matplotlib.lines.Line2D at 0xe55b8c10>]
│ │ │ │ +Out[18]: [<matplotlib.lines.Line2D at 0xa48afd30>]
│ │ │ │
│ │ │ │ In [19]: da.interp(x=np.linspace(0, 1, 100), method="cubic").plot.line(label="cubic")
│ │ │ │ -Out[19]: [<matplotlib.lines.Line2D at 0xe865f7f0>]
│ │ │ │ +Out[19]: [<matplotlib.lines.Line2D at 0xa48afe38>]
│ │ │ │
│ │ │ │ In [20]: plt.legend()
│ │ │ │ -Out[20]: <matplotlib.legend.Legend at 0xe3442ca0>
│ │ │ │ +Out[20]: <matplotlib.legend.Legend at 0xa26bae50>
│ │ │ │
│ │ │ │
│ │ │ │ 
│ │ │ │ Additional keyword arguments can be passed to scipy’s functions.
│ │ │ │ # fill 0 for the outside of the original coordinates.
│ │ │ │ In [21]: da.interp(x=np.linspace(-0.5, 1.5, 10), kwargs={"fill_value": 0.0})
│ │ │ │ Out[21]:
│ │ │ │ @@ -611,15 +611,15 @@
│ │ │ │ /build/reproducible-path/python-xarray-0.16.2/xarray/tutorial.py in open_dataset(name, cache, cache_dir, github_url, branch, **kws)
│ │ │ │ 76 # May want to add an option to remove it.
│ │ │ │ 77 if not _os.path.isdir(longdir):
│ │ │ │ ---> 78 _os.mkdir(longdir)
│ │ │ │ 79
│ │ │ │ 80 url = "/".join((github_url, "raw", branch, fullname))
│ │ │ │
│ │ │ │ -FileNotFoundError: [Errno 2] No such file or directory: '/nonexistent/first-build/.xarray_tutorial_data'
│ │ │ │ +FileNotFoundError: [Errno 2] No such file or directory: '/nonexistent/second-build/.xarray_tutorial_data'
│ │ │ │
│ │ │ │ In [45]: fig, axes = plt.subplots(ncols=2, figsize=(10, 4))
│ │ │ │
│ │ │ │ In [46]: ds.air.plot(ax=axes[0])
│ │ │ │ ---------------------------------------------------------------------------
│ │ │ │ AttributeError Traceback (most recent call last)
│ │ │ │ <ipython-input-46-cb8f083667be> in <module>
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -202,26 +202,26 @@
│ │ │ │ │ ....: np.sin(np.linspace(0, 2 * np.pi, 10)),
│ │ │ │ │ ....: dims="x",
│ │ │ │ │ ....: coords={"x": np.linspace(0, 1, 10)},
│ │ │ │ │ ....: )
│ │ │ │ │ ....:
│ │ │ │ │
│ │ │ │ │ In [17]: da.plot.line("o", label="original")
│ │ │ │ │ -Out[17]: []
│ │ │ │ │ +Out[17]: []
│ │ │ │ │
│ │ │ │ │ In [18]: da.interp(x=np.linspace(0, 1, 100)).plot.line(label="linear
│ │ │ │ │ (default)")
│ │ │ │ │ -Out[18]: []
│ │ │ │ │ +Out[18]: []
│ │ │ │ │
│ │ │ │ │ In [19]: da.interp(x=np.linspace(0, 1, 100), method="cubic").plot.line
│ │ │ │ │ (label="cubic")
│ │ │ │ │ -Out[19]: []
│ │ │ │ │ +Out[19]: []
│ │ │ │ │
│ │ │ │ │ In [20]: plt.legend()
│ │ │ │ │ -Out[20]:
│ │ │ │ │ +Out[20]:
│ │ │ │ │ [_images/interpolation_sample1.png]
│ │ │ │ │ Additional keyword arguments can be passed to scipyâs functions.
│ │ │ │ │ # fill 0 for the outside of the original coordinates.
│ │ │ │ │ In [21]: da.interp(x=np.linspace(-0.5, 1.5, 10), kwargs={"fill_value": 0.0})
│ │ │ │ │ Out[21]:
│ │ │ │ │
│ │ │ │ │ array([ 0. , 0. , 0. , 0.814, 0.604, -0.604, -0.814, 0. , 0. ,
│ │ │ │ │ @@ -390,15 +390,15 @@
│ │ │ │ │ open_dataset(name, cache, cache_dir, github_url, branch, **kws)
│ │ │ │ │ 76 # May want to add an option to remove it.
│ │ │ │ │ 77 if not _os.path.isdir(longdir):
│ │ │ │ │ ---> 78 _os.mkdir(longdir)
│ │ │ │ │ 79
│ │ │ │ │ 80 url = "/".join((github_url, "raw", branch, fullname))
│ │ │ │ │
│ │ │ │ │ -FileNotFoundError: [Errno 2] No such file or directory: '/nonexistent/first-
│ │ │ │ │ +FileNotFoundError: [Errno 2] No such file or directory: '/nonexistent/second-
│ │ │ │ │ build/.xarray_tutorial_data'
│ │ │ │ │
│ │ │ │ │ In [45]: fig, axes = plt.subplots(ncols=2, figsize=(10, 4))
│ │ │ │ │
│ │ │ │ │ In [46]: ds.air.plot(ax=axes[0])
│ │ │ │ │ ---------------------------------------------------------------------------
│ │ │ │ │ AttributeError Traceback (most recent call last)
│ │ │ ├── ./usr/share/doc/python-xarray-doc/html/io.html
│ │ │ │ @@ -1059,15 +1059,15 @@
│ │ │ │ ....: "y": pd.date_range("2000-01-01", periods=5),
│ │ │ │ ....: "z": ("x", list("abcd")),
│ │ │ │ ....: },
│ │ │ │ ....: )
│ │ │ │ ....:
│ │ │ │
│ │ │ │ In [39]: ds.to_zarr("path/to/directory.zarr")
│ │ │ │ -Out[39]: <xarray.backends.zarr.ZarrStore at 0xe2c9ebf8>
│ │ │ │ +Out[39]: <xarray.backends.zarr.ZarrStore at 0xa1f0f9e8>
│ │ │ │
│ │ │ │
(The suffix .zarr is optional–just a reminder that a zarr store lives
│ │ │ │ there.) If the directory does not exist, it will be created. If a zarr
│ │ │ │ store is already present at that path, an error will be raised, preventing it
│ │ │ │ from being overwritten. To override this behavior and overwrite an existing
│ │ │ │ store, add mode='w' when invoking to_zarr().
│ │ │ │ @@ -1113,15 +1113,15 @@
│ │ │ │ These options can be passed to the to_zarr method as variable encoding.
│ │ │ │ For example:
│ │ │ │ In [42]: import zarr
│ │ │ │
│ │ │ │ In [43]: compressor = zarr.Blosc(cname="zstd", clevel=3, shuffle=2)
│ │ │ │
│ │ │ │ In [44]: ds.to_zarr("foo.zarr", encoding={"foo": {"compressor": compressor}})
│ │ │ │ -Out[44]: <xarray.backends.zarr.ZarrStore at 0xe2cb7418>
│ │ │ │ +Out[44]: <xarray.backends.zarr.ZarrStore at 0xa1f21298>
│ │ │ │
│ │ │ │
│ │ │ │
Note
│ │ │ │
Not all native zarr compression and filtering options have been tested with
│ │ │ │ xarray.
│ │ │ │
Finally, you can use region to write to limited regions of existing arrays
│ │ │ │ in an existing Zarr store. This is a good option for writing data in parallel
│ │ │ │ from independent processes.
│ │ │ │ To scale this up to writing large datasets, the first step is creating an
│ │ │ │ initial Zarr store without writing all of its array data. This can be done by
│ │ │ │ @@ -1218,33 +1218,33 @@
│ │ │ │
│ │ │ │ In [51]: ds = xr.Dataset({"foo": ("x", dummies)})
│ │ │ │
│ │ │ │ In [52]: path = "path/to/directory.zarr"
│ │ │ │
│ │ │ │ # Now we write the metadata without computing any array values
│ │ │ │ In [53]: ds.to_zarr(path, compute=False, consolidated=True)
│ │ │ │ -Out[53]: Delayed('_finalize_store-1a13d624-cacf-4160-83a2-84bc57f54340')
│ │ │ │ +Out[53]: Delayed('_finalize_store-84826c16-f21f-4c17-b8bf-0c71a9942837')
│ │ │ │
│ │ │ │
│ │ │ │
Now, a Zarr store with the correct variable shapes and attributes exists that
│ │ │ │ can be filled out by subsequent calls to to_zarr. The region provides a
│ │ │ │ mapping from dimension names to Python slice objects indicating where the
│ │ │ │ data should be written (in index space, not coordinate space), e.g.,
│ │ │ │ # For convenience, we'll slice a single dataset, but in the real use-case
│ │ │ │ # we would create them separately, possibly even from separate processes.
│ │ │ │ In [54]: ds = xr.Dataset({"foo": ("x", np.arange(30))})
│ │ │ │
│ │ │ │ In [55]: ds.isel(x=slice(0, 10)).to_zarr(path, region={"x": slice(0, 10)})
│ │ │ │ -Out[55]: <xarray.backends.zarr.ZarrStore at 0xe2cb7928>
│ │ │ │ +Out[55]: <xarray.backends.zarr.ZarrStore at 0xa1f219e8>
│ │ │ │
│ │ │ │ In [56]: ds.isel(x=slice(10, 20)).to_zarr(path, region={"x": slice(10, 20)})
│ │ │ │ -Out[56]: <xarray.backends.zarr.ZarrStore at 0xe8774418>
│ │ │ │ +Out[56]: <xarray.backends.zarr.ZarrStore at 0xa49351a8>
│ │ │ │
│ │ │ │ In [57]: ds.isel(x=slice(20, 30)).to_zarr(path, region={"x": slice(20, 30)})
│ │ │ │ -Out[57]: <xarray.backends.zarr.ZarrStore at 0xe7fc4c88>
│ │ │ │ +Out[57]: <xarray.backends.zarr.ZarrStore at 0xa5133c88>
│ │ │ │
│ │ │ │
Concurrent writes with region are safe as long as they modify distinct
│ │ │ │ chunks in the underlying Zarr arrays (or use an appropriate lock).
│ │ │ │ As a safety check to make it harder to inadvertently override existing values,
│ │ │ │ if you set region then all variables included in a Dataset must have
│ │ │ │ dimensions included in region. Other variables (typically coordinates)
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -762,15 +762,15 @@
│ │ │ │ │ ....: "y": pd.date_range("2000-01-01", periods=5),
│ │ │ │ │ ....: "z": ("x", list("abcd")),
│ │ │ │ │ ....: },
│ │ │ │ │ ....: )
│ │ │ │ │ ....:
│ │ │ │ │
│ │ │ │ │ In [39]: ds.to_zarr("path/to/directory.zarr")
│ │ │ │ │ -Out[39]:
│ │ │ │ │ +Out[39]:
│ │ │ │ │ (The suffix .zarr is optionalâjust a reminder that a zarr store lives there.)
│ │ │ │ │ If the directory does not exist, it will be created. If a zarr store is already
│ │ │ │ │ present at that path, an error will be raised, preventing it from being
│ │ │ │ │ overwritten. To override this behavior and overwrite an existing store, add
│ │ │ │ │ mode='w' when invoking to_zarr().
│ │ │ │ │ To store variable length strings, convert them to object arrays first with
│ │ │ │ │ dtype=object.
│ │ │ │ │ @@ -806,15 +806,15 @@
│ │ │ │ │ zarr. These are described in the zarr_documentation. These options can be
│ │ │ │ │ passed to the to_zarr method as variable encoding. For example:
│ │ │ │ │ In [42]: import zarr
│ │ │ │ │
│ │ │ │ │ In [43]: compressor = zarr.Blosc(cname="zstd", clevel=3, shuffle=2)
│ │ │ │ │
│ │ │ │ │ In [44]: ds.to_zarr("foo.zarr", encoding={"foo": {"compressor": compressor}})
│ │ │ │ │ -Out[44]:
│ │ │ │ │ +Out[44]:
│ │ │ │ │ Note
│ │ │ │ │ Not all native zarr compression and filtering options have been tested with
│ │ │ │ │ xarray.
│ │ │ │ │ **** Consolidated Metadata¶ ****
│ │ │ │ │ Xarray needs to read all of the zarr metadata when it opens a dataset. In some
│ │ │ │ │ storage mediums, such as with cloud object storage (e.g. amazon S3), this can
│ │ │ │ │ introduce significant overhead, because two separate HTTP calls to the object
│ │ │ │ │ @@ -854,28 +854,28 @@
│ │ │ │ │ ....: "y": [1, 2, 3, 4, 5],
│ │ │ │ │ ....: "t": pd.date_range("2001-01-01", periods=2),
│ │ │ │ │ ....: },
│ │ │ │ │ ....: )
│ │ │ │ │ ....:
│ │ │ │ │
│ │ │ │ │ In [46]: ds1.to_zarr("path/to/directory.zarr")
│ │ │ │ │ -Out[46]:
│ │ │ │ │ +Out[46]:
│ │ │ │ │
│ │ │ │ │ In [47]: ds2 = xr.Dataset(
│ │ │ │ │ ....: {"foo": (("x", "y", "t"), np.random.rand(4, 5, 2))},
│ │ │ │ │ ....: coords={
│ │ │ │ │ ....: "x": [10, 20, 30, 40],
│ │ │ │ │ ....: "y": [1, 2, 3, 4, 5],
│ │ │ │ │ ....: "t": pd.date_range("2001-01-03", periods=2),
│ │ │ │ │ ....: },
│ │ │ │ │ ....: )
│ │ │ │ │ ....:
│ │ │ │ │
│ │ │ │ │ In [48]: ds2.to_zarr("path/to/directory.zarr", append_dim="t")
│ │ │ │ │ -Out[48]:
│ │ │ │ │ +Out[48]:
│ │ │ │ │ Finally, you can use region to write to limited regions of existing arrays in
│ │ │ │ │ an existing Zarr store. This is a good option for writing data in parallel from
│ │ │ │ │ independent processes.
│ │ │ │ │ To scale this up to writing large datasets, the first step is creating an
│ │ │ │ │ initial Zarr store without writing all of its array data. This can be done by
│ │ │ │ │ first creating a Dataset with dummy values stored in dask, and then calling
│ │ │ │ │ to_zarr with compute=False to write only metadata (including attrs) to Zarr:
│ │ │ │ │ @@ -887,31 +887,31 @@
│ │ │ │ │
│ │ │ │ │ In [51]: ds = xr.Dataset({"foo": ("x", dummies)})
│ │ │ │ │
│ │ │ │ │ In [52]: path = "path/to/directory.zarr"
│ │ │ │ │
│ │ │ │ │ # Now we write the metadata without computing any array values
│ │ │ │ │ In [53]: ds.to_zarr(path, compute=False, consolidated=True)
│ │ │ │ │ -Out[53]: Delayed('_finalize_store-1a13d624-cacf-4160-83a2-84bc57f54340')
│ │ │ │ │ +Out[53]: Delayed('_finalize_store-84826c16-f21f-4c17-b8bf-0c71a9942837')
│ │ │ │ │ Now, a Zarr store with the correct variable shapes and attributes exists that
│ │ │ │ │ can be filled out by subsequent calls to to_zarr. The region provides a mapping
│ │ │ │ │ from dimension names to Python slice objects indicating where the data should
│ │ │ │ │ be written (in index space, not coordinate space), e.g.,
│ │ │ │ │ # For convenience, we'll slice a single dataset, but in the real use-case
│ │ │ │ │ # we would create them separately, possibly even from separate processes.
│ │ │ │ │ In [54]: ds = xr.Dataset({"foo": ("x", np.arange(30))})
│ │ │ │ │
│ │ │ │ │ In [55]: ds.isel(x=slice(0, 10)).to_zarr(path, region={"x": slice(0, 10)})
│ │ │ │ │ -Out[55]:
│ │ │ │ │ +Out[55]:
│ │ │ │ │
│ │ │ │ │ In [56]: ds.isel(x=slice(10, 20)).to_zarr(path, region={"x": slice(10, 20)})
│ │ │ │ │ -Out[56]:
│ │ │ │ │ +Out[56]:
│ │ │ │ │
│ │ │ │ │ In [57]: ds.isel(x=slice(20, 30)).to_zarr(path, region={"x": slice(20, 30)})
│ │ │ │ │ -Out[57]:
│ │ │ │ │ +Out[57]:
│ │ │ │ │ Concurrent writes with region are safe as long as they modify distinct chunks
│ │ │ │ │ in the underlying Zarr arrays (or use an appropriate lock).
│ │ │ │ │ As a safety check to make it harder to inadvertently override existing values,
│ │ │ │ │ if you set region then all variables included in a Dataset must have dimensions
│ │ │ │ │ included in region. Other variables (typically coordinates) need to be
│ │ │ │ │ explicitly dropped and/or written in a separate calls to to_zarr with mode='a'.
│ │ │ │ │ ***** GRIB format via cfgrib¶ *****
│ │ │ ├── ./usr/share/doc/python-xarray-doc/html/plotting.html
│ │ │ │ @@ -326,15 +326,15 @@
│ │ │ │ /build/reproducible-path/python-xarray-0.16.2/xarray/tutorial.py in open_dataset(name, cache, cache_dir, github_url, branch, **kws)
│ │ │ │ 76 # May want to add an option to remove it.
│ │ │ │ 77 if not _os.path.isdir(longdir):
│ │ │ │ ---> 78 _os.mkdir(longdir)
│ │ │ │ 79
│ │ │ │ 80 url = "/".join((github_url, "raw", branch, fullname))
│ │ │ │
│ │ │ │ -FileNotFoundError: [Errno 2] No such file or directory: '/nonexistent/first-build/.xarray_tutorial_data'
│ │ │ │ +FileNotFoundError: [Errno 2] No such file or directory: '/nonexistent/second-build/.xarray_tutorial_data'
│ │ │ │
│ │ │ │ In [6]: airtemps
│ │ │ │ ---------------------------------------------------------------------------
│ │ │ │ NameError Traceback (most recent call last)
│ │ │ │ <ipython-input-6-eb57b540ddce> in <module>
│ │ │ │ ----> 1 airtemps
│ │ │ │
│ │ │ │ @@ -852,15 +852,15 @@
│ │ │ │ --> 171 ref_var = variables[ref_name]
│ │ │ │ 172
│ │ │ │ 173 if var_name is None:
│ │ │ │
│ │ │ │ KeyError: 'lat'
│ │ │ │
│ │ │ │ In [51]: b.plot()
│ │ │ │ -Out[51]: [<matplotlib.lines.Line2D at 0xe29532b0>]
│ │ │ │ +Out[51]: [<matplotlib.lines.Line2D at 0xa1bc43e8>]
│ │ │ │
│ │ │ │
│ │ │ │ 
│ │ │ │
│ │ │ │
│ │ │ │
Calling Matplotlib
│ │ │ │
Since this is a thin wrapper around matplotlib, all the functionality of
│ │ │ │ @@ -1314,56 +1314,56 @@
│ │ │ │ Data variables:
│ │ │ │ A (x, y, z, w) float64 -0.104 0.02719 -0.0425 ... -0.1175 -0.0183
│ │ │ │ B (x, y, z, w) float64 0.0 0.0 0.0 0.0 ... 1.369 1.408 1.387 1.417
│ │ │ │
Suppose we want to scatter A against B
│ │ │ │ In [95]: ds.plot.scatter(x="A", y="B")
│ │ │ │ -Out[95]: <matplotlib.collections.PathCollection at 0xe2c48160>
│ │ │ │ +Out[95]: <matplotlib.collections.PathCollection at 0xa1ec6be0>
│ │ │ │
│ │ │ │
│ │ │ │ The hue kwarg lets you vary the color by variable value
│ │ │ │ In [96]: ds.plot.scatter(x="A", y="B", hue="w")
│ │ │ │ Out[96]:
│ │ │ │ -[<matplotlib.collections.PathCollection at 0xe55b30b8>,
│ │ │ │ - <matplotlib.collections.PathCollection at 0xe5763d60>,
│ │ │ │ - <matplotlib.collections.PathCollection at 0xe5863070>,
│ │ │ │ - <matplotlib.collections.PathCollection at 0xe557a568>]
│ │ │ │ +[<matplotlib.collections.PathCollection at 0xa26baca0>,
│ │ │ │ + <matplotlib.collections.PathCollection at 0xa4829430>,
│ │ │ │ + <matplotlib.collections.PathCollection at 0xa497e7c0>,
│ │ │ │ + <matplotlib.collections.PathCollection at 0xa51066e8>]
│ │ │ │
│ │ │ │
│ │ │ │ When hue is specified, a colorbar is added for numeric hue DataArrays by
│ │ │ │ default and a legend is added for non-numeric hue DataArrays (as above).
│ │ │ │ You can force a legend instead of a colorbar by setting hue_style='discrete'.
│ │ │ │ Additionally, the boolean kwarg add_guide can be used to prevent the display of a legend or colorbar (as appropriate).
│ │ │ │ In [97]: ds = ds.assign(w=[1, 2, 3, 5])
│ │ │ │
│ │ │ │ In [98]: ds.plot.scatter(x="A", y="B", hue="w", hue_style="discrete")
│ │ │ │ Out[98]:
│ │ │ │ -[<matplotlib.collections.PathCollection at 0xe2915610>,
│ │ │ │ - <matplotlib.collections.PathCollection at 0xe291de50>,
│ │ │ │ - <matplotlib.collections.PathCollection at 0xe27abad8>,
│ │ │ │ - <matplotlib.collections.PathCollection at 0xe291dec8>]
│ │ │ │ +[<matplotlib.collections.PathCollection at 0xa1b85ca0>,
│ │ │ │ + <matplotlib.collections.PathCollection at 0xa1b8cf70>,
│ │ │ │ + <matplotlib.collections.PathCollection at 0xa1a1dbb0>,
│ │ │ │ + <matplotlib.collections.PathCollection at 0xa1a20b98>]
│ │ │ │
│ │ │ │
│ │ │ │ The markersize kwarg lets you vary the point’s size by variable value. You can additionally pass size_norm to control how the variable’s values are mapped to point sizes.
│ │ │ │ In [99]: ds.plot.scatter(x="A", y="B", hue="z", hue_style="discrete", markersize="z")
│ │ │ │ Out[99]:
│ │ │ │ -[<matplotlib.collections.PathCollection at 0xe2751e98>,
│ │ │ │ - <matplotlib.collections.PathCollection at 0xe27abf58>,
│ │ │ │ - <matplotlib.collections.PathCollection at 0xe27b6cd0>,
│ │ │ │ - <matplotlib.collections.PathCollection at 0xe27b13e8>]
│ │ │ │ +[<matplotlib.collections.PathCollection at 0xa1a2e190>,
│ │ │ │ + <matplotlib.collections.PathCollection at 0xa1a20d78>,
│ │ │ │ + <matplotlib.collections.PathCollection at 0xa1a20f88>,
│ │ │ │ + <matplotlib.collections.PathCollection at 0xa1a23508>]
│ │ │ │
│ │ │ │
│ │ │ │ Faceting is also possible
│ │ │ │ In [100]: ds.plot.scatter(x="A", y="B", col="x", row="z", hue="w", hue_style="discrete")
│ │ │ │ -Out[100]: <xarray.plot.facetgrid.FacetGrid at 0xe7fb1250>
│ │ │ │ +Out[100]: <xarray.plot.facetgrid.FacetGrid at 0xa1b85a00>
│ │ │ │
│ │ │ │
│ │ │ │ For more advanced scatter plots, we recommend converting the relevant data variables to a pandas DataFrame and using the extensive plotting capabilities of seaborn.
│ │ │ │
│ │ │ │
│ │ │ │
Maps
│ │ │ │ @@ -1380,15 +1380,15 @@
│ │ │ │
/build/reproducible-path/python-xarray-0.16.2/xarray/tutorial.py in
open_dataset(name, cache, cache_dir, github_url, branch, **kws)
│ │ │ │
76 # May want to add an option to remove it.
│ │ │ │
77 if not _os.path.isdir(longdir):
│ │ │ │
---> 78 _os.mkdir(longdir)
│ │ │ │
79
│ │ │ │
80 url = "/".join((github_url, "raw", branch, fullname))
│ │ │ │
│ │ │ │ -
FileNotFoundError: [Errno 2] No such file or directory: '/nonexistent/first-build/.xarray_tutorial_data'
│ │ │ │ +
FileNotFoundError: [Errno 2] No such file or directory: '/nonexistent/second-build/.xarray_tutorial_data'
│ │ │ │
│ │ │ │
In [103]: p = air.isel(time=0).plot(
│ │ │ │
.....: subplot_kws=dict(projection=ccrs.Orthographic(-80, 35), facecolor="gray"),
│ │ │ │
.....: transform=ccrs.PlateCarree(),
│ │ │ │
.....: )
│ │ │ │
.....:
│ │ │ │
---------------------------------------------------------------------------
│ │ │ │ @@ -1472,24 +1472,24 @@
│ │ │ │
In [109]: import xarray.plot as xplt
│ │ │ │
│ │ │ │ In [110]: da = xr.DataArray(range(5))
│ │ │ │
│ │ │ │ In [111]: fig, axes = plt.subplots(ncols=2, nrows=2)
│ │ │ │
│ │ │ │ In [112]: da.plot(ax=axes[0, 0])
│ │ │ │ -Out[112]: [<matplotlib.lines.Line2D at 0xe1ee2c88>]
│ │ │ │ +Out[112]: [<matplotlib.lines.Line2D at 0xa11bfd78>]
│ │ │ │
│ │ │ │ In [113]: da.plot.line(ax=axes[0, 1])
│ │ │ │ -Out[113]: [<matplotlib.lines.Line2D at 0xe1f05c40>]
│ │ │ │ +Out[113]: [<matplotlib.lines.Line2D at 0xb305b9a0>]
│ │ │ │
│ │ │ │ In [114]: xplt.plot(da, ax=axes[1, 0])
│ │ │ │ -Out[114]: [<matplotlib.lines.Line2D at 0xe1f2b7a8>]
│ │ │ │ +Out[114]: [<matplotlib.lines.Line2D at 0xb3024688>]
│ │ │ │
│ │ │ │ In [115]: xplt.line(da, ax=axes[1, 1])
│ │ │ │ -Out[115]: [<matplotlib.lines.Line2D at 0xe1f2a700>]
│ │ │ │ +Out[115]: [<matplotlib.lines.Line2D at 0xb3075f88>]
│ │ │ │
│ │ │ │ In [116]: plt.tight_layout()
│ │ │ │
│ │ │ │ In [117]: plt.draw()
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ @@ -1542,15 +1542,15 @@
│ │ │ │
The plot will produce an image corresponding to the values of the array.
│ │ │ │ Hence the top left pixel will be a different color than the others.
│ │ │ │ Before reading on, you may want to look at the coordinates and
│ │ │ │ think carefully about what the limits, labels, and orientation for
│ │ │ │ each of the axes should be.
│ │ │ │ In [122]: a.plot()
│ │ │ │ -Out[122]: <matplotlib.collections.QuadMesh at 0xe2435b20>
│ │ │ │ +Out[122]: <matplotlib.collections.QuadMesh at 0xa16abfd0>
│ │ │ │
│ │ │ │
│ │ │ │ It may seem strange that
│ │ │ │ the values on the y axis are decreasing with -0.5 on the top. This is because
│ │ │ │ the pixels are centered over their coordinates, and the
│ │ │ │ axis labels and ranges correspond to the values of the
│ │ │ │ @@ -1572,81 +1572,81 @@
│ │ │ │ .....: np.arange(20).reshape(4, 5),
│ │ │ │ .....: dims=["y", "x"],
│ │ │ │ .....: coords={"lat": (("y", "x"), lat), "lon": (("y", "x"), lon)},
│ │ │ │ .....: )
│ │ │ │ .....:
│ │ │ │
│ │ │ │ In [127]: da.plot.pcolormesh("lon", "lat")
│ │ │ │ -Out[127]: <matplotlib.collections.QuadMesh at 0xe8188748>
│ │ │ │ +Out[127]: <matplotlib.collections.QuadMesh at 0xa1f34910>
│ │ │ │
│ │ │ │
│ │ │ │ 
│ │ │ │
Note that in this case, xarray still follows the pixel centered convention.
│ │ │ │ This might be undesirable in some cases, for example when your data is defined
│ │ │ │ on a polar projection (GH781). This is why the default is to not follow
│ │ │ │ this convention when plotting on a map:
│ │ │ │ In [128]: import cartopy.crs as ccrs
│ │ │ │
│ │ │ │ In [129]: ax = plt.subplot(projection=ccrs.PlateCarree())
│ │ │ │
│ │ │ │ In [130]: da.plot.pcolormesh("lon", "lat", ax=ax)
│ │ │ │ -Out[130]: <matplotlib.collections.QuadMesh at 0xe22b31c0>
│ │ │ │ +Out[130]: <matplotlib.collections.QuadMesh at 0xa152c2b0>
│ │ │ │
│ │ │ │ In [131]: ax.scatter(lon, lat, transform=ccrs.PlateCarree())
│ │ │ │ -Out[131]: <matplotlib.collections.PathCollection at 0xe2254478>
│ │ │ │ +Out[131]: <matplotlib.collections.PathCollection at 0xa1548568>
│ │ │ │
│ │ │ │ In [132]: ax.coastlines()
│ │ │ │ -Out[132]: <cartopy.mpl.feature_artist.FeatureArtist at 0xe2298ce8>
│ │ │ │ +Out[132]: <cartopy.mpl.feature_artist.FeatureArtist at 0xa0c16dc0>
│ │ │ │
│ │ │ │ In [133]: ax.gridlines(draw_labels=True)
│ │ │ │ -Out[133]: <cartopy.mpl.gridliner.Gridliner at 0xe2254598>
│ │ │ │ +Out[133]: <cartopy.mpl.gridliner.Gridliner at 0xa1548688>
│ │ │ │
│ │ │ │
│ │ │ │ You can however decide to infer the cell boundaries and use the
│ │ │ │ infer_intervals keyword:
│ │ │ │ In [134]: ax = plt.subplot(projection=ccrs.PlateCarree())
│ │ │ │
│ │ │ │ In [135]: da.plot.pcolormesh("lon", "lat", ax=ax, infer_intervals=True)
│ │ │ │ -Out[135]: <matplotlib.collections.QuadMesh at 0xe22bef10>
│ │ │ │ +Out[135]: <matplotlib.collections.QuadMesh at 0xa1534a00>
│ │ │ │
│ │ │ │ In [136]: ax.scatter(lon, lat, transform=ccrs.PlateCarree())
│ │ │ │ -Out[136]: <matplotlib.collections.PathCollection at 0xe2148328>
│ │ │ │ +Out[136]: <matplotlib.collections.PathCollection at 0xa13bf418>
│ │ │ │
│ │ │ │ In [137]: ax.coastlines()
│ │ │ │ -Out[137]: <cartopy.mpl.feature_artist.FeatureArtist at 0xe2261838>
│ │ │ │ +Out[137]: <cartopy.mpl.feature_artist.FeatureArtist at 0xa14d7970>
│ │ │ │
│ │ │ │ In [138]: ax.gridlines(draw_labels=True)
│ │ │ │ -Out[138]: <cartopy.mpl.gridliner.Gridliner at 0xe22bebc8>
│ │ │ │ +Out[138]: <cartopy.mpl.gridliner.Gridliner at 0xa1534cb8>
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
Note
│ │ │ │
The data model of xarray does not support datasets with cell boundaries
│ │ │ │ yet. If you want to use these coordinates, you’ll have to make the plots
│ │ │ │ outside the xarray framework.
│ │ │ │
One can also make line plots with multidimensional coordinates. In this case, hue must be a dimension name, not a coordinate name.
│ │ │ │ In [139]: f, ax = plt.subplots(2, 1)
│ │ │ │
│ │ │ │ In [140]: da.plot.line(x="lon", hue="y", ax=ax[0])
│ │ │ │ Out[140]:
│ │ │ │ -[<matplotlib.lines.Line2D at 0xe22615c8>,
│ │ │ │ - <matplotlib.lines.Line2D at 0xe22618f8>,
│ │ │ │ - <matplotlib.lines.Line2D at 0xe22cecb8>,
│ │ │ │ - <matplotlib.lines.Line2D at 0xe2148d00>]
│ │ │ │ +[<matplotlib.lines.Line2D at 0xa14d7a18>,
│ │ │ │ + <matplotlib.lines.Line2D at 0xa14d7a30>,
│ │ │ │ + <matplotlib.lines.Line2D at 0xa1542a30>,
│ │ │ │ + <matplotlib.lines.Line2D at 0xa0c16ec8>]
│ │ │ │
│ │ │ │ In [141]: da.plot.line(x="lon", hue="x", ax=ax[1])
│ │ │ │ Out[141]:
│ │ │ │ -[<matplotlib.lines.Line2D at 0xe209f928>,
│ │ │ │ - <matplotlib.lines.Line2D at 0xe209f958>,
│ │ │ │ - <matplotlib.lines.Line2D at 0xe209f988>,
│ │ │ │ - <matplotlib.lines.Line2D at 0xe209f9e8>,
│ │ │ │ - <matplotlib.lines.Line2D at 0xe209fa48>]
│ │ │ │ +[<matplotlib.lines.Line2D at 0xa1319a18>,
│ │ │ │ + <matplotlib.lines.Line2D at 0xa1319a48>,
│ │ │ │ + <matplotlib.lines.Line2D at 0xa1319a78>,
│ │ │ │ + <matplotlib.lines.Line2D at 0xa1319ad8>,
│ │ │ │ + <matplotlib.lines.Line2D at 0xa1319b38>]
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -121,15 +121,15 @@
│ │ │ │ │ open_dataset(name, cache, cache_dir, github_url, branch, **kws)
│ │ │ │ │ 76 # May want to add an option to remove it.
│ │ │ │ │ 77 if not _os.path.isdir(longdir):
│ │ │ │ │ ---> 78 _os.mkdir(longdir)
│ │ │ │ │ 79
│ │ │ │ │ 80 url = "/".join((github_url, "raw", branch, fullname))
│ │ │ │ │
│ │ │ │ │ -FileNotFoundError: [Errno 2] No such file or directory: '/nonexistent/first-
│ │ │ │ │ +FileNotFoundError: [Errno 2] No such file or directory: '/nonexistent/second-
│ │ │ │ │ build/.xarray_tutorial_data'
│ │ │ │ │
│ │ │ │ │ In [6]: airtemps
│ │ │ │ │ ---------------------------------------------------------------------------
│ │ │ │ │ NameError Traceback (most recent call last)
│ │ │ │ │ in
│ │ │ │ │ ----> 1 airtemps
│ │ │ │ │ @@ -588,15 +588,15 @@
│ │ │ │ │ --> 171 ref_var = variables[ref_name]
│ │ │ │ │ 172
│ │ │ │ │ 173 if var_name is None:
│ │ │ │ │
│ │ │ │ │ KeyError: 'lat'
│ │ │ │ │
│ │ │ │ │ In [51]: b.plot()
│ │ │ │ │ -Out[51]: []
│ │ │ │ │ +Out[51]: []
│ │ │ │ │ [_images/plotting_nonuniform_coords.png]
│ │ │ │ │ *** Calling Matplotlib¶ ***
│ │ │ │ │ Since this is a thin wrapper around matplotlib, all the functionality of
│ │ │ │ │ matplotlib is available.
│ │ │ │ │ In [52]: air2d.plot(cmap=plt.cm.Blues)
│ │ │ │ │ ---------------------------------------------------------------------------
│ │ │ │ │ NameError Traceback (most recent call last)
│ │ │ │ │ @@ -984,53 +984,53 @@
│ │ │ │ │ * z (z) int32 0 1 2 3
│ │ │ │ │ * w (w)
│ │ │ │ │ +Out[95]:
│ │ │ │ │ [_images/ds_simple_scatter.png]
│ │ │ │ │ The hue kwarg lets you vary the color by variable value
│ │ │ │ │ In [96]: ds.plot.scatter(x="A", y="B", hue="w")
│ │ │ │ │ Out[96]:
│ │ │ │ │ -[,
│ │ │ │ │ - ,
│ │ │ │ │ - ,
│ │ │ │ │ - ]
│ │ │ │ │ +[,
│ │ │ │ │ + ,
│ │ │ │ │ + ,
│ │ │ │ │ + ]
│ │ │ │ │ [_images/ds_hue_scatter.png]
│ │ │ │ │ When hue is specified, a colorbar is added for numeric hue DataArrays by
│ │ │ │ │ default and a legend is added for non-numeric hue DataArrays (as above). You
│ │ │ │ │ can force a legend instead of a colorbar by setting hue_style='discrete'.
│ │ │ │ │ Additionally, the boolean kwarg add_guide can be used to prevent the display of
│ │ │ │ │ a legend or colorbar (as appropriate).
│ │ │ │ │ In [97]: ds = ds.assign(w=[1, 2, 3, 5])
│ │ │ │ │
│ │ │ │ │ In [98]: ds.plot.scatter(x="A", y="B", hue="w", hue_style="discrete")
│ │ │ │ │ Out[98]:
│ │ │ │ │ -[,
│ │ │ │ │ - ,
│ │ │ │ │ - ,
│ │ │ │ │ - ]
│ │ │ │ │ +[,
│ │ │ │ │ + ,
│ │ │ │ │ + ,
│ │ │ │ │ + ]
│ │ │ │ │ [_images/ds_discrete_legend_hue_scatter.png]
│ │ │ │ │ The markersize kwarg lets you vary the pointâs size by variable value. You
│ │ │ │ │ can additionally pass size_norm to control how the variableâs values are
│ │ │ │ │ mapped to point sizes.
│ │ │ │ │ In [99]: ds.plot.scatter(x="A", y="B", hue="z", hue_style="discrete",
│ │ │ │ │ markersize="z")
│ │ │ │ │ Out[99]:
│ │ │ │ │ -[,
│ │ │ │ │ - ,
│ │ │ │ │ - ,
│ │ │ │ │ - ]
│ │ │ │ │ +[,
│ │ │ │ │ + ,
│ │ │ │ │ + ,
│ │ │ │ │ + ]
│ │ │ │ │ [_images/ds_hue_size_scatter.png]
│ │ │ │ │ Faceting is also possible
│ │ │ │ │ In [100]: ds.plot.scatter(x="A", y="B", col="x", row="z", hue="w",
│ │ │ │ │ hue_style="discrete")
│ │ │ │ │ -Out[100]:
│ │ │ │ │ +Out[100]:
│ │ │ │ │ [_images/ds_facet_scatter.png]
│ │ │ │ │ For more advanced scatter plots, we recommend converting the relevant data
│ │ │ │ │ variables to a pandas DataFrame and using the extensive plotting capabilities
│ │ │ │ │ of seaborn.
│ │ │ │ │ ***** Maps¶ *****
│ │ │ │ │ To follow this section youâll need to have Cartopy installed and working.
│ │ │ │ │ This script will plot the air temperature on a map.
│ │ │ │ │ @@ -1046,15 +1046,15 @@
│ │ │ │ │ open_dataset(name, cache, cache_dir, github_url, branch, **kws)
│ │ │ │ │ 76 # May want to add an option to remove it.
│ │ │ │ │ 77 if not _os.path.isdir(longdir):
│ │ │ │ │ ---> 78 _os.mkdir(longdir)
│ │ │ │ │ 79
│ │ │ │ │ 80 url = "/".join((github_url, "raw", branch, fullname))
│ │ │ │ │
│ │ │ │ │ -FileNotFoundError: [Errno 2] No such file or directory: '/nonexistent/first-
│ │ │ │ │ +FileNotFoundError: [Errno 2] No such file or directory: '/nonexistent/second-
│ │ │ │ │ build/.xarray_tutorial_data'
│ │ │ │ │
│ │ │ │ │ In [103]: p = air.isel(time=0).plot(
│ │ │ │ │ .....: subplot_kws=dict(projection=ccrs.Orthographic(-80, 35),
│ │ │ │ │ facecolor="gray"),
│ │ │ │ │ .....: transform=ccrs.PlateCarree(),
│ │ │ │ │ .....: )
│ │ │ │ │ @@ -1131,24 +1131,24 @@
│ │ │ │ │ In [109]: import xarray.plot as xplt
│ │ │ │ │
│ │ │ │ │ In [110]: da = xr.DataArray(range(5))
│ │ │ │ │
│ │ │ │ │ In [111]: fig, axes = plt.subplots(ncols=2, nrows=2)
│ │ │ │ │
│ │ │ │ │ In [112]: da.plot(ax=axes[0, 0])
│ │ │ │ │ -Out[112]: []
│ │ │ │ │ +Out[112]: []
│ │ │ │ │
│ │ │ │ │ In [113]: da.plot.line(ax=axes[0, 1])
│ │ │ │ │ -Out[113]: []
│ │ │ │ │ +Out[113]: []
│ │ │ │ │
│ │ │ │ │ In [114]: xplt.plot(da, ax=axes[1, 0])
│ │ │ │ │ -Out[114]: []
│ │ │ │ │ +Out[114]: []
│ │ │ │ │
│ │ │ │ │ In [115]: xplt.line(da, ax=axes[1, 1])
│ │ │ │ │ -Out[115]: []
│ │ │ │ │ +Out[115]: []
│ │ │ │ │
│ │ │ │ │ In [116]: plt.tight_layout()
│ │ │ │ │
│ │ │ │ │ In [117]: plt.draw()
│ │ │ │ │ [_images/plotting_ways_to_use.png]
│ │ │ │ │ Here the output is the same. Since the data is 1 dimensional the line plot was
│ │ │ │ │ used.
│ │ │ │ │ @@ -1179,15 +1179,15 @@
│ │ │ │ │ [0., 0., 0.]])
│ │ │ │ │ Dimensions without coordinates: y, x
│ │ │ │ │ The plot will produce an image corresponding to the values of the array. Hence
│ │ │ │ │ the top left pixel will be a different color than the others. Before reading
│ │ │ │ │ on, you may want to look at the coordinates and think carefully about what the
│ │ │ │ │ limits, labels, and orientation for each of the axes should be.
│ │ │ │ │ In [122]: a.plot()
│ │ │ │ │ -Out[122]:
│ │ │ │ │ +Out[122]:
│ │ │ │ │ [_images/plotting_example_2d_simple.png]
│ │ │ │ │ It may seem strange that the values on the y axis are decreasing with -0.5 on
│ │ │ │ │ the top. This is because the pixels are centered over their coordinates, and
│ │ │ │ │ the axis labels and ranges correspond to the values of the coordinates.
│ │ │ │ │ **** Multidimensional coordinates¶ ****
│ │ │ │ │ See also: Working_with_Multidimensional_Coordinates.
│ │ │ │ │ You can plot irregular grids defined by multidimensional coordinates with
│ │ │ │ │ @@ -1204,72 +1204,72 @@
│ │ │ │ │ .....: np.arange(20).reshape(4, 5),
│ │ │ │ │ .....: dims=["y", "x"],
│ │ │ │ │ .....: coords={"lat": (("y", "x"), lat), "lon": (("y", "x"), lon)},
│ │ │ │ │ .....: )
│ │ │ │ │ .....:
│ │ │ │ │
│ │ │ │ │ In [127]: da.plot.pcolormesh("lon", "lat")
│ │ │ │ │ -Out[127]:
│ │ │ │ │ +Out[127]:
│ │ │ │ │ [_images/plotting_example_2d_irreg.png]
│ │ │ │ │ Note that in this case, xarray still follows the pixel centered convention.
│ │ │ │ │ This might be undesirable in some cases, for example when your data is defined
│ │ │ │ │ on a polar projection (GH781). This is why the default is to not follow this
│ │ │ │ │ convention when plotting on a map:
│ │ │ │ │ In [128]: import cartopy.crs as ccrs
│ │ │ │ │
│ │ │ │ │ In [129]: ax = plt.subplot(projection=ccrs.PlateCarree())
│ │ │ │ │
│ │ │ │ │ In [130]: da.plot.pcolormesh("lon", "lat", ax=ax)
│ │ │ │ │ -Out[130]:
│ │ │ │ │ +Out[130]:
│ │ │ │ │
│ │ │ │ │ In [131]: ax.scatter(lon, lat, transform=ccrs.PlateCarree())
│ │ │ │ │ -Out[131]:
│ │ │ │ │ +Out[131]:
│ │ │ │ │
│ │ │ │ │ In [132]: ax.coastlines()
│ │ │ │ │ -Out[132]:
│ │ │ │ │ +Out[132]:
│ │ │ │ │
│ │ │ │ │ In [133]: ax.gridlines(draw_labels=True)
│ │ │ │ │ -Out[133]:
│ │ │ │ │ +Out[133]:
│ │ │ │ │ [_build/html/_static/plotting_example_2d_irreg_map.png]
│ │ │ │ │ You can however decide to infer the cell boundaries and use the infer_intervals
│ │ │ │ │ keyword:
│ │ │ │ │ In [134]: ax = plt.subplot(projection=ccrs.PlateCarree())
│ │ │ │ │
│ │ │ │ │ In [135]: da.plot.pcolormesh("lon", "lat", ax=ax, infer_intervals=True)
│ │ │ │ │ -Out[135]:
│ │ │ │ │ +Out[135]:
│ │ │ │ │
│ │ │ │ │ In [136]: ax.scatter(lon, lat, transform=ccrs.PlateCarree())
│ │ │ │ │ -Out[136]:
│ │ │ │ │ +Out[136]:
│ │ │ │ │
│ │ │ │ │ In [137]: ax.coastlines()
│ │ │ │ │ -Out[137]:
│ │ │ │ │ +Out[137]:
│ │ │ │ │
│ │ │ │ │ In [138]: ax.gridlines(draw_labels=True)
│ │ │ │ │ -Out[138]:
│ │ │ │ │ +Out[138]:
│ │ │ │ │ [_build/html/_static/plotting_example_2d_irreg_map_infer.png]
│ │ │ │ │ Note
│ │ │ │ │ The data model of xarray does not support datasets with cell_boundaries yet. If
│ │ │ │ │ you want to use these coordinates, youâll have to make the plots outside the
│ │ │ │ │ xarray framework.
│ │ │ │ │ One can also make line plots with multidimensional coordinates. In this case,
│ │ │ │ │ hue must be a dimension name, not a coordinate name.
│ │ │ │ │ In [139]: f, ax = plt.subplots(2, 1)
│ │ │ │ │
│ │ │ │ │ In [140]: da.plot.line(x="lon", hue="y", ax=ax[0])
│ │ │ │ │ Out[140]:
│ │ │ │ │ -[,
│ │ │ │ │ - ,
│ │ │ │ │ - ,
│ │ │ │ │ - ]
│ │ │ │ │ +[,
│ │ │ │ │ + ,
│ │ │ │ │ + ,
│ │ │ │ │ + ]
│ │ │ │ │
│ │ │ │ │ In [141]: da.plot.line(x="lon", hue="x", ax=ax[1])
│ │ │ │ │ Out[141]:
│ │ │ │ │ -[,
│ │ │ │ │ - ,
│ │ │ │ │ - ,
│ │ │ │ │ - ,
│ │ │ │ │ - ]
│ │ │ │ │ +[,
│ │ │ │ │ + ,
│ │ │ │ │ + ,
│ │ │ │ │ + ,
│ │ │ │ │ + ]
│ │ │ │ │ [_images/plotting_example_2d_hue_xy.png]
│ │ │ │ │ Next Previous
│ │ │ │ │ ===============================================================================
│ │ │ │ │ © Copyright 2014-2021, xarray Developers. Last updated on 2021-01-02.
│ │ │ │ │ Built with Sphinx using a theme provided by Read_the_Docs.
│ │ │ ├── ./usr/share/doc/python-xarray-doc/html/quick-overview.html
│ │ │ │ @@ -498,15 +498,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
Plotting
│ │ │ │
Visualizing your datasets is quick and convenient:
│ │ │ │
In [37]: data.plot()
│ │ │ │ -Out[37]: <matplotlib.collections.QuadMesh at 0xe2023d78>
│ │ │ │ +Out[37]: <matplotlib.collections.QuadMesh at 0xa129be68>
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
Note the automatic labeling with names and units. Our effort in adding metadata attributes has paid off! Many aspects of these figures are customizable: see Plotting.
│ │ │ │
│ │ │ │
pandas
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -304,15 +304,15 @@
│ │ │ │ │ [0.787, 0. , 1.199]])
│ │ │ │ │ Coordinates:
│ │ │ │ │ * x (x) int32 10 20
│ │ │ │ │ Dimensions without coordinates: y
│ │ │ │ │ ***** Plotting¶ *****
│ │ │ │ │ Visualizing your datasets is quick and convenient:
│ │ │ │ │ In [37]: data.plot()
│ │ │ │ │ -Out[37]:
│ │ │ │ │ +Out[37]:
│ │ │ │ │ [_images/plotting_quick_overview.png]
│ │ │ │ │ Note the automatic labeling with names and units. Our effort in adding metadata
│ │ │ │ │ attributes has paid off! Many aspects of these figures are customizable: see
│ │ │ │ │ Plotting.
│ │ │ │ │ ***** pandas¶ *****
│ │ │ │ │ Xarray objects can be easily converted to and from pandas objects using the
│ │ │ │ │ to_series(), to_dataframe() and to_xarray() methods:
│ │ │ ├── ./usr/share/doc/python-xarray-doc/html/searchindex.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -146,75 +146,76 @@
│ │ │ │ │ "09038344": 4,
│ │ │ │ │ "094": 22,
│ │ │ │ │ "096": 22,
│ │ │ │ │ "09705329": 4,
│ │ │ │ │ "09t00": 6,
│ │ │ │ │ "0alpha10": 36,
│ │ │ │ │ "0c0dc80c25a9": 6,
│ │ │ │ │ + "0c71a9942837": 26,
│ │ │ │ │ "0e8985178ccc": 26,
│ │ │ │ │ "0eb806e38f7f": [14, 15],
│ │ │ │ │ "0f41191e8013": 28,
│ │ │ │ │ "0th": [6, 22],
│ │ │ │ │ "0x0l": 36,
│ │ │ │ │ - "0xe12d79e8": 36,
│ │ │ │ │ - "0xe1ee2c88": 28,
│ │ │ │ │ - "0xe1f05c40": 28,
│ │ │ │ │ - "0xe1f2a700": 28,
│ │ │ │ │ - "0xe1f2b7a8": 28,
│ │ │ │ │ - "0xe2023d78": 29,
│ │ │ │ │ - "0xe209f928": 28,
│ │ │ │ │ - "0xe209f958": 28,
│ │ │ │ │ - "0xe209f988": 28,
│ │ │ │ │ - "0xe209f9e8": 28,
│ │ │ │ │ - "0xe209fa48": 28,
│ │ │ │ │ - "0xe2148328": 28,
│ │ │ │ │ - "0xe2148d00": 28,
│ │ │ │ │ - "0xe2254478": 28,
│ │ │ │ │ - "0xe2254598": 28,
│ │ │ │ │ - "0xe22615c8": 28,
│ │ │ │ │ - "0xe2261838": 28,
│ │ │ │ │ - "0xe22618f8": 28,
│ │ │ │ │ - "0xe2298ce8": 28,
│ │ │ │ │ - "0xe22b31c0": 28,
│ │ │ │ │ - "0xe22bebc8": 28,
│ │ │ │ │ - "0xe22bef10": 28,
│ │ │ │ │ - "0xe22cecb8": 28,
│ │ │ │ │ - "0xe2435b20": 28,
│ │ │ │ │ - "0xe2751e98": 28,
│ │ │ │ │ - "0xe27abad8": 28,
│ │ │ │ │ - "0xe27abf58": 28,
│ │ │ │ │ - "0xe27b13e8": 28,
│ │ │ │ │ - "0xe27b6cd0": 28,
│ │ │ │ │ - "0xe2915610": 28,
│ │ │ │ │ - "0xe291de50": 28,
│ │ │ │ │ - "0xe291dec8": 28,
│ │ │ │ │ - "0xe29532b0": 28,
│ │ │ │ │ - "0xe2c48160": 28,
│ │ │ │ │ - "0xe2c9ebf8": 26,
│ │ │ │ │ - "0xe2cb7418": 26,
│ │ │ │ │ - "0xe2cb7538": 26,
│ │ │ │ │ - "0xe2cb7928": 26,
│ │ │ │ │ - "0xe2cb7a78": 26,
│ │ │ │ │ - "0xe3442ca0": 25,
│ │ │ │ │ - "0xe557a568": 28,
│ │ │ │ │ - "0xe55b30b8": 28,
│ │ │ │ │ - "0xe55b8b68": 25,
│ │ │ │ │ - "0xe55b8c10": 25,
│ │ │ │ │ - "0xe55e2ce8": 24,
│ │ │ │ │ - "0xe5763d60": 28,
│ │ │ │ │ - "0xe5863070": 28,
│ │ │ │ │ - "0xe7fb1250": 28,
│ │ │ │ │ - "0xe7fb6ef8": 7,
│ │ │ │ │ - "0xe7fbd2b0": 7,
│ │ │ │ │ - "0xe7fc4c88": 26,
│ │ │ │ │ - "0xe8188748": 28,
│ │ │ │ │ - "0xe865f7f0": 25,
│ │ │ │ │ - "0xe8774418": 26,
│ │ │ │ │ - "0xe9089bf8": 16,
│ │ │ │ │ - "0xf51e8838": 17,
│ │ │ │ │ + "0xa0551ad8": 36,
│ │ │ │ │ + "0xa0c16dc0": 28,
│ │ │ │ │ + "0xa0c16ec8": 28,
│ │ │ │ │ + "0xa11bfd78": 28,
│ │ │ │ │ + "0xa129be68": 29,
│ │ │ │ │ + "0xa1319a18": 28,
│ │ │ │ │ + "0xa1319a48": 28,
│ │ │ │ │ + "0xa1319a78": 28,
│ │ │ │ │ + "0xa1319ad8": 28,
│ │ │ │ │ + "0xa1319b38": 28,
│ │ │ │ │ + "0xa13bf418": 28,
│ │ │ │ │ + "0xa14d7970": 28,
│ │ │ │ │ + "0xa14d7a18": 28,
│ │ │ │ │ + "0xa14d7a30": 28,
│ │ │ │ │ + "0xa152c2b0": 28,
│ │ │ │ │ + "0xa1534a00": 28,
│ │ │ │ │ + "0xa1534cb8": 28,
│ │ │ │ │ + "0xa1542a30": 28,
│ │ │ │ │ + "0xa1548568": 28,
│ │ │ │ │ + "0xa1548688": 28,
│ │ │ │ │ + "0xa16abfd0": 28,
│ │ │ │ │ + "0xa1a1dbb0": 28,
│ │ │ │ │ + "0xa1a20b98": 28,
│ │ │ │ │ + "0xa1a20d78": 28,
│ │ │ │ │ + "0xa1a20f88": 28,
│ │ │ │ │ + "0xa1a23508": 28,
│ │ │ │ │ + "0xa1a2e190": 28,
│ │ │ │ │ + "0xa1b85a00": 28,
│ │ │ │ │ + "0xa1b85ca0": 28,
│ │ │ │ │ + "0xa1b8cf70": 28,
│ │ │ │ │ + "0xa1bc43e8": 28,
│ │ │ │ │ + "0xa1ec6be0": 28,
│ │ │ │ │ + "0xa1f0f9e8": 26,
│ │ │ │ │ + "0xa1f21298": 26,
│ │ │ │ │ + "0xa1f214d8": 26,
│ │ │ │ │ + "0xa1f21958": 26,
│ │ │ │ │ + "0xa1f219e8": 26,
│ │ │ │ │ + "0xa1f34910": 28,
│ │ │ │ │ + "0xa26baca0": 28,
│ │ │ │ │ + "0xa26bae50": 25,
│ │ │ │ │ + "0xa4829430": 28,
│ │ │ │ │ + "0xa48afd30": 25,
│ │ │ │ │ + "0xa48afe38": 25,
│ │ │ │ │ + "0xa49351a8": 26,
│ │ │ │ │ + "0xa497e7c0": 28,
│ │ │ │ │ + "0xa4bc6ce8": 24,
│ │ │ │ │ + "0xa50b1fb8": 7,
│ │ │ │ │ + "0xa50ba370": 7,
│ │ │ │ │ + "0xa51066e8": 28,
│ │ │ │ │ + "0xa5133c88": 26,
│ │ │ │ │ + "0xa8148eb0": 25,
│ │ │ │ │ + "0xa83ffbf8": 16,
│ │ │ │ │ + "0xb3024688": 28,
│ │ │ │ │ + "0xb305b9a0": 28,
│ │ │ │ │ + "0xb3075f88": 28,
│ │ │ │ │ + "0xb41db820": 17,
│ │ │ │ │ "100": [3, 4, 6, 11, 12, 22, 25, 26, 28, 31, 36],
│ │ │ │ │ "1000": [6, 36],
│ │ │ │ │ "100000": 6,
│ │ │ │ │ "1000x1000": 6,
│ │ │ │ │ "1003": 4,
│ │ │ │ │ "101": [4, 22, 28, 36],
│ │ │ │ │ "101985": 26,
│ │ │ │ │ @@ -399,15 +400,14 @@
│ │ │ │ │ "1970": [32, 36],
│ │ │ │ │ "198": 16,
│ │ │ │ │ "199": [16, 29],
│ │ │ │ │ "1991": 36,
│ │ │ │ │ "1999": 4,
│ │ │ │ │ "19t00": 6,
│ │ │ │ │ "1MS": 17,
│ │ │ │ │ - "1a13d624": 26,
│ │ │ │ │ "1c96aded89da": 10,
│ │ │ │ │ "1d37fb2cd247": 24,
│ │ │ │ │ "1d727aa86050": 28,
│ │ │ │ │ "1e6": 4,
│ │ │ │ │ "1st": 22,
│ │ │ │ │ "200": [4, 16, 28, 31],
│ │ │ │ │ "2000": [4, 7, 17, 18, 22, 25, 26, 27, 34, 35, 36],
│ │ │ │ │ @@ -719,15 +719,14 @@
│ │ │ │ │ "41156272": 4,
│ │ │ │ │ "41184582": 4,
│ │ │ │ │ "41198807": 4,
│ │ │ │ │ "412": 10,
│ │ │ │ │ "4123": 4,
│ │ │ │ │ "413": 10,
│ │ │ │ │ "414": 22,
│ │ │ │ │ - "4160": 26,
│ │ │ │ │ "4162c0ac1db4": 28,
│ │ │ │ │ "4167": 26,
│ │ │ │ │ "417": 28,
│ │ │ │ │ "41753485ddae": 28,
│ │ │ │ │ "41d6431c1ce8": 26,
│ │ │ │ │ "424": 27,
│ │ │ │ │ "425": 4,
│ │ │ │ │ @@ -788,14 +787,15 @@
│ │ │ │ │ "4867138": 4,
│ │ │ │ │ "48671934": 4,
│ │ │ │ │ "48672119": 4,
│ │ │ │ │ "492914": 17,
│ │ │ │ │ "494929": 27,
│ │ │ │ │ "495": 27,
│ │ │ │ │ "497": 22,
│ │ │ │ │ + "4c17": 26,
│ │ │ │ │ "500": [16, 26, 28, 36],
│ │ │ │ │ "501": 29,
│ │ │ │ │ "5011": 3,
│ │ │ │ │ "502": 25,
│ │ │ │ │ "504": 19,
│ │ │ │ │ "506234": 17,
│ │ │ │ │ "508": 25,
│ │ │ │ │ @@ -881,14 +881,15 @@
│ │ │ │ │ "609": 19,
│ │ │ │ │ "60f8bca41fc7": 28,
│ │ │ │ │ "6106": 4,
│ │ │ │ │ "610f8fdf815a": 28,
│ │ │ │ │ "611": 22,
│ │ │ │ │ "612e": 26,
│ │ │ │ │ "613": 22,
│ │ │ │ │ + "616fe0734e26416bb4b6b0639e0646cdtemperatur": 6,
│ │ │ │ │ "621": 26,
│ │ │ │ │ "624": 29,
│ │ │ │ │ "625": 26,
│ │ │ │ │ "62b0a60dbc78": 28,
│ │ │ │ │ "635": [25, 29],
│ │ │ │ │ "63593435": 17,
│ │ │ │ │ "636": 17,
│ │ │ │ │ @@ -1029,24 +1030,23 @@
│ │ │ │ │ "82979374": 4,
│ │ │ │ │ "829e": 6,
│ │ │ │ │ "82f9ba4c4771": 22,
│ │ │ │ │ "833": [26, 27],
│ │ │ │ │ "8333": [25, 26],
│ │ │ │ │ "8362b177be7e": 28,
│ │ │ │ │ "839": 22,
│ │ │ │ │ - "83a2": 26,
│ │ │ │ │ "8402550832613813": 26,
│ │ │ │ │ "8403": 19,
│ │ │ │ │ "8415": 36,
│ │ │ │ │ "8421": 17,
│ │ │ │ │ "84210526": 17,
│ │ │ │ │ "8434966": 17,
│ │ │ │ │ + "84826c16": 26,
│ │ │ │ │ "849": 4,
│ │ │ │ │ "84b392f0a7d9": 28,
│ │ │ │ │ - "84bc57f54340": 26,
│ │ │ │ │ "853905": 17,
│ │ │ │ │ "8548": 17,
│ │ │ │ │ "85483871": 17,
│ │ │ │ │ "858e": 35,
│ │ │ │ │ "8598787065799693": 26,
│ │ │ │ │ "8599": 22,
│ │ │ │ │ "8601": [35, 36],
│ │ │ │ │ @@ -1075,15 +1075,14 @@
│ │ │ │ │ "888": 25,
│ │ │ │ │ "889425": 17,
│ │ │ │ │ "892": 27,
│ │ │ │ │ "893": 25,
│ │ │ │ │ "897": [7, 22],
│ │ │ │ │ "8972": [19, 26],
│ │ │ │ │ "8972365243645735": 26,
│ │ │ │ │ - "8991b1b144f62b67334e42d6ce128e3etemperatur": 6,
│ │ │ │ │ "89bc1504b066": 28,
│ │ │ │ │ "8ff3ba4430a3": 28,
│ │ │ │ │ "9014": 4,
│ │ │ │ │ "904": 7,
│ │ │ │ │ "909": 7,
│ │ │ │ │ "911": 25,
│ │ │ │ │ "912": 25,
│ │ │ │ │ @@ -1575,14 +1574,15 @@
│ │ │ │ │ azur: [5, 36],
│ │ │ │ │ b0dd519cfb30: 28,
│ │ │ │ │ b0e609ec01c0: 22,
│ │ │ │ │ b193806a3ee8: 28,
│ │ │ │ │ b347cf3a8c47: 28,
│ │ │ │ │ b7284116c837: 15,
│ │ │ │ │ b834aeff258: 28,
│ │ │ │ │ + b8bf: 26,
│ │ │ │ │ back: [4, 6, 7, 12, 18, 19, 22, 24, 26, 28, 29, 31, 36, 37],
│ │ │ │ │ backend: [1, 6, 10, 16, 22, 23, 24, 26, 32, 36],
│ │ │ │ │ backend_bas: 10,
│ │ │ │ │ backend_kwarg: [26, 36],
│ │ │ │ │ backfil: 22,
│ │ │ │ │ background: [7, 32],
│ │ │ │ │ backoff: 36,
│ │ │ │ │ @@ -1728,15 +1728,14 @@
│ │ │ │ │ bytestr: 36,
│ │ │ │ │ c46381dcb349: 12,
│ │ │ │ │ c743efa1dcb: 28,
│ │ │ │ │ c7d6afd7f8c5: 28,
│ │ │ │ │ ca9ab8433617: 28,
│ │ │ │ │ ca9decd7dd88: 28,
│ │ │ │ │ cabl: 36,
│ │ │ │ │ - cacf: 26,
│ │ │ │ │ cach: [5, 10, 11, 12, 13, 14, 15, 16, 22, 24, 25, 28, 32, 36],
│ │ │ │ │ cache_dir: [10, 11, 12, 13, 14, 15, 16, 22, 24, 25, 28],
│ │ │ │ │ cachedir: 5,
│ │ │ │ │ cachingfilemanag: 16,
│ │ │ │ │ calcul: [4, 6, 9, 13, 15, 28, 30, 34, 36],
│ │ │ │ │ caleb: 36,
│ │ │ │ │ calendar: [14, 23, 25, 26, 34, 36],
│ │ │ │ │ @@ -2462,14 +2461,15 @@
│ │ │ │ │ extent_geom: 10,
│ │ │ │ │ extern: [1, 7, 8, 26, 32, 36],
│ │ │ │ │ extra: [10, 12, 23, 36],
│ │ │ │ │ extract: [6, 20, 31, 36],
│ │ │ │ │ extrapol: [25, 36],
│ │ │ │ │ extras_requir: 23,
│ │ │ │ │ extrem: [6, 22, 26, 28],
│ │ │ │ │ + f21f: 26,
│ │ │ │ │ f2ef6402a2c4: 28,
│ │ │ │ │ f4da044a917f: 28,
│ │ │ │ │ f6219653038f: 12,
│ │ │ │ │ f62677abb3ca: 25,
│ │ │ │ │ f6e5aae51f8: 11,
│ │ │ │ │ f75038449fe8: 28,
│ │ │ │ │ f9603d06ba9e: 26,
│ │ │ │ │ @@ -2545,15 +2545,15 @@
│ │ │ │ │ filter_by_attr: 36,
│ │ │ │ │ financ: [32, 37],
│ │ │ │ │ find: [0, 1, 5, 8, 18, 20, 22, 26, 28, 32, 36],
│ │ │ │ │ fine: [5, 26],
│ │ │ │ │ finish: [5, 36],
│ │ │ │ │ finit: [4, 15, 30, 36],
│ │ │ │ │ firm: 18,
│ │ │ │ │ - first: [1, 3, 4, 5, 6, 7, 10, 11, 12, 13, 14, 15, 16, 17, 22, 23, 24, 25, 26, 28, 29, 32, 34, 36],
│ │ │ │ │ + first: [1, 3, 4, 5, 6, 7, 12, 13, 14, 16, 17, 22, 23, 24, 25, 26, 28, 29, 32, 34, 36],
│ │ │ │ │ fiscal: [21, 32, 36],
│ │ │ │ │ fit: [6, 18, 26, 28, 32, 36],
│ │ │ │ │ fitzgerald: [18, 36],
│ │ │ │ │ five: [28, 36],
│ │ │ │ │ fix: [1, 5, 6, 7, 12, 18, 23, 26, 28, 33, 35],
│ │ │ │ │ fixtur: 5,
│ │ │ │ │ flag: [5, 18, 36],
│ │ │ │ │ @@ -4978,15 +4978,15 @@
│ │ │ │ │ seaborn: [23, 27, 28, 36],
│ │ │ │ │ seamlessli: 5,
│ │ │ │ │ search: [5, 26],
│ │ │ │ │ searchsort: 1,
│ │ │ │ │ season: [9, 17, 34, 35, 36],
│ │ │ │ │ season_mean: 14,
│ │ │ │ │ sec: 29,
│ │ │ │ │ - second: [3, 5, 7, 12, 16, 22, 24, 26, 27, 29, 34, 35],
│ │ │ │ │ + second: [3, 5, 7, 10, 11, 12, 13, 14, 15, 16, 22, 24, 25, 26, 27, 28, 29, 34, 35],
│ │ │ │ │ section: [5, 11, 18, 23, 26, 28, 30, 36],
│ │ │ │ │ see: [1, 3, 4, 5, 6, 7, 8, 11, 12, 16, 18, 20, 22, 23, 24, 25, 26, 27, 28, 29, 30, 32, 33, 34, 35, 36, 37],
│ │ │ │ │ seed: 17,
│ │ │ │ │ seem: [11, 12, 28, 36],
│ │ │ │ │ seen: [4, 19, 23],
│ │ │ │ │ segment: 36,
│ │ │ │ │ seguinot: 36,
│ │ │ ├── ./usr/share/doc/python-xarray-doc/html/whats-new.html
│ │ │ │ @@ -4447,15 +4447,15 @@
│ │ │ │ New xray.Dataset.where method for masking xray objects according
│ │ │ │ to some criteria. This works particularly well with multi-dimensional data:
│ │ │ │ In [44]: ds = xray.Dataset(coords={"x": range(100), "y": range(100)})
│ │ │ │
│ │ │ │ In [45]: ds["distance"] = np.sqrt(ds.x ** 2 + ds.y ** 2)
│ │ │ │
│ │ │ │ In [46]: ds.distance.where(ds.distance < 100).plot()
│ │ │ │ -Out[46]: <matplotlib.collections.QuadMesh at 0xe12d79e8>
│ │ │ │ +Out[46]: <matplotlib.collections.QuadMesh at 0xa0551ad8>
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ Added new methods xray.DataArray.diff and xray.Dataset.diff
│ │ │ │ for finite difference calculations along a given axis.
│ │ │ │ New xray.DataArray.to_masked_array convenience method for
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -2957,15 +2957,15 @@
│ │ │ │ │ * New xray.Dataset.where method for masking xray objects according to some
│ │ │ │ │ criteria. This works particularly well with multi-dimensional data:
│ │ │ │ │ In [44]: ds = xray.Dataset(coords={"x": range(100), "y": range(100)})
│ │ │ │ │
│ │ │ │ │ In [45]: ds["distance"] = np.sqrt(ds.x ** 2 + ds.y ** 2)
│ │ │ │ │
│ │ │ │ │ In [46]: ds.distance.where(ds.distance < 100).plot()
│ │ │ │ │ - Out[46]:
│ │ │ │ │ + Out[46]:
│ │ │ │ │ [_images/where_example.png]
│ │ │ │ │ * Added new methods xray.DataArray.diff and xray.Dataset.diff for finite
│ │ │ │ │ difference calculations along a given axis.
│ │ │ │ │ * New xray.DataArray.to_masked_array convenience method for returning a
│ │ │ │ │ numpy.ma.MaskedArray.
│ │ │ │ │ In [47]: da = xray.DataArray(np.random.random_sample(size=(5, 4)))
│ │ │ │ @@ -1507,26 +1507,26 @@
│ │ │ │ [0. , 0. , 0. ],
│ │ │ │ [0. , 0. , 0. ],
│ │ │ │ [0. , 0.01612903, 0. ],
│ │ │ │ [0.33333333, 0.35 , 0.23333333],
│ │ │ │ [0.93548387, 0.85483871, 0.82258065]])
│ │ │ │ Coordinates:
│ │ │ │ * location (location) <U2 'IA' 'IN' 'IL'
│ │ │ │ - * month (month) int64 1 2 3 4 5 6 7 8 9 10 11 12