auto_combine(datasets[, concat_dim, compat, …])

Attempt to auto-magically combine the given datasets into one.

Dataset.nbytes

Dataset.chunks

Block dimensions for this dataset’s data or None if it’s not a dask array.

Dataset.all([dim])

Reduce this Dataset’s data by applying all along some dimension(s).

Dataset.any([dim])

Reduce this Dataset’s data by applying any along some dimension(s).

Dataset.argmax([dim, skipna])

Reduce this Dataset’s data by applying argmax along some dimension(s).

Dataset.argmin([dim, skipna])

Reduce this Dataset’s data by applying argmin along some dimension(s).

Dataset.max([dim, skipna])

Reduce this Dataset’s data by applying max along some dimension(s).

Dataset.min([dim, skipna])

Reduce this Dataset’s data by applying min along some dimension(s).

Dataset.mean([dim, skipna])

Reduce this Dataset’s data by applying mean along some dimension(s).

Dataset.median([dim, skipna])

Reduce this Dataset’s data by applying median along some dimension(s).

Dataset.prod([dim, skipna])

Reduce this Dataset’s data by applying prod along some dimension(s).

Dataset.sum([dim, skipna])

Reduce this Dataset’s data by applying sum along some dimension(s).

Dataset.std([dim, skipna])

Reduce this Dataset’s data by applying std along some dimension(s).

Dataset.var([dim, skipna])

Reduce this Dataset’s data by applying var along some dimension(s).

core.coordinates.DatasetCoordinates.get(k[,d])

core.coordinates.DatasetCoordinates.items()

core.coordinates.DatasetCoordinates.keys()

core.coordinates.DatasetCoordinates.merge(other)

Merge two sets of coordinates to create a new Dataset

core.coordinates.DatasetCoordinates.to_dataset()

Convert these coordinates into a new Dataset

core.coordinates.DatasetCoordinates.to_index([…])

Convert all index coordinates into a pandas.Index.

core.coordinates.DatasetCoordinates.update(other)

core.coordinates.DatasetCoordinates.values()

core.coordinates.DatasetCoordinates.dims

core.coordinates.DatasetCoordinates.indexes

core.coordinates.DatasetCoordinates.variables

core.rolling.DatasetCoarsen.all(**kwargs)

Reduce this DatasetCoarsen’s data by applying all along some dimension(s).

core.rolling.DatasetCoarsen.any(**kwargs)

Reduce this DatasetCoarsen’s data by applying any along some dimension(s).

core.rolling.DatasetCoarsen.argmax(**kwargs)

Reduce this DatasetCoarsen’s data by applying argmax along some dimension(s).

core.rolling.DatasetCoarsen.argmin(**kwargs)

Reduce this DatasetCoarsen’s data by applying argmin along some dimension(s).

core.rolling.DatasetCoarsen.count(**kwargs)

Reduce this DatasetCoarsen’s data by applying count along some dimension(s).

core.rolling.DatasetCoarsen.max(**kwargs)

Reduce this DatasetCoarsen’s data by applying max along some dimension(s).

core.rolling.DatasetCoarsen.mean(**kwargs)

Reduce this DatasetCoarsen’s data by applying mean along some dimension(s).

core.rolling.DatasetCoarsen.median(**kwargs)

Reduce this DatasetCoarsen’s data by applying median along some dimension(s).

core.rolling.DatasetCoarsen.min(**kwargs)

Reduce this DatasetCoarsen’s data by applying min along some dimension(s).

core.rolling.DatasetCoarsen.prod(**kwargs)

Reduce this DatasetCoarsen’s data by applying prod along some dimension(s).

core.rolling.DatasetCoarsen.std(**kwargs)

Reduce this DatasetCoarsen’s data by applying std along some dimension(s).

core.rolling.DatasetCoarsen.sum(**kwargs)

Reduce this DatasetCoarsen’s data by applying sum along some dimension(s).

core.rolling.DatasetCoarsen.var(**kwargs)

Reduce this DatasetCoarsen’s data by applying var along some dimension(s).

core.rolling.DatasetCoarsen.boundary

core.rolling.DatasetCoarsen.coord_func

core.rolling.DatasetCoarsen.obj

core.rolling.DatasetCoarsen.side

core.rolling.DatasetCoarsen.trim_excess

core.rolling.DatasetCoarsen.windows

core.groupby.DatasetGroupBy.assign(**kwargs)

Assign data variables by group.

core.groupby.DatasetGroupBy.assign_coords([…])

Assign coordinates by group.

core.groupby.DatasetGroupBy.first([skipna, …])

Return the first element of each group along the group dimension

core.groupby.DatasetGroupBy.last([skipna, …])

Return the last element of each group along the group dimension

core.groupby.DatasetGroupBy.fillna(value)

Fill missing values in this object by group.

core.groupby.DatasetGroupBy.quantile(q[, …])

Compute the qth quantile over each array in the groups and concatenate them together into a new array.

core.groupby.DatasetGroupBy.where(cond[, other])

Return elements from self or other depending on cond.

core.groupby.DatasetGroupBy.all([dim])

Reduce this DatasetGroupBy’s data by applying all along some dimension(s).

core.groupby.DatasetGroupBy.any([dim])

Reduce this DatasetGroupBy’s data by applying any along some dimension(s).

core.groupby.DatasetGroupBy.argmax([dim, skipna])

Reduce this DatasetGroupBy’s data by applying argmax along some dimension(s).

core.groupby.DatasetGroupBy.argmin([dim, skipna])

Reduce this DatasetGroupBy’s data by applying argmin along some dimension(s).

core.groupby.DatasetGroupBy.count([dim])

Reduce this DatasetGroupBy’s data by applying count along some dimension(s).

core.groupby.DatasetGroupBy.max([dim, skipna])

Reduce this DatasetGroupBy’s data by applying max along some dimension(s).

core.groupby.DatasetGroupBy.mean([dim, skipna])

Reduce this DatasetGroupBy’s data by applying mean along some dimension(s).

core.groupby.DatasetGroupBy.median([dim, skipna])

Reduce this DatasetGroupBy’s data by applying median along some dimension(s).

core.groupby.DatasetGroupBy.min([dim, skipna])

Reduce this DatasetGroupBy’s data by applying min along some dimension(s).

core.groupby.DatasetGroupBy.prod([dim, skipna])

Reduce this DatasetGroupBy’s data by applying prod along some dimension(s).

core.groupby.DatasetGroupBy.std([dim, skipna])

Reduce this DatasetGroupBy’s data by applying std along some dimension(s).

core.groupby.DatasetGroupBy.sum([dim, skipna])

Reduce this DatasetGroupBy’s data by applying sum along some dimension(s).

core.groupby.DatasetGroupBy.var([dim, skipna])

Reduce this DatasetGroupBy’s data by applying var along some dimension(s).

core.groupby.DatasetGroupBy.dims

core.groupby.DatasetGroupBy.groups

core.resample.DatasetResample.all([dim])

Reduce this DatasetResample’s data by applying all along some dimension(s).

core.resample.DatasetResample.any([dim])

Reduce this DatasetResample’s data by applying any along some dimension(s).

core.resample.DatasetResample.apply(func[, …])

Backward compatible implementation of map

core.resample.DatasetResample.argmax([dim, …])

Reduce this DatasetResample’s data by applying argmax along some dimension(s).

core.resample.DatasetResample.argmin([dim, …])

Reduce this DatasetResample’s data by applying argmin along some dimension(s).

core.resample.DatasetResample.assign(**kwargs)

Assign data variables by group.

core.resample.DatasetResample.assign_coords([…])

Assign coordinates by group.

core.resample.DatasetResample.bfill([tolerance])

Backward fill new values at up-sampled frequency.

core.resample.DatasetResample.count([dim])

Reduce this DatasetResample’s data by applying count along some dimension(s).

core.resample.DatasetResample.ffill([tolerance])

Forward fill new values at up-sampled frequency.

core.resample.DatasetResample.fillna(value)

Fill missing values in this object by group.

core.resample.DatasetResample.first([…])

Return the first element of each group along the group dimension

core.resample.DatasetResample.last([skipna, …])

Return the last element of each group along the group dimension

core.resample.DatasetResample.map(func[, …])

Apply a function over each Dataset in the groups generated for resampling and concatenate them together into a new Dataset.

core.resample.DatasetResample.max([dim, skipna])

Reduce this DatasetResample’s data by applying max along some dimension(s).

core.resample.DatasetResample.mean([dim, skipna])

Reduce this DatasetResample’s data by applying mean along some dimension(s).

core.resample.DatasetResample.median([dim, …])

Reduce this DatasetResample’s data by applying median along some dimension(s).

core.resample.DatasetResample.min([dim, skipna])

Reduce this DatasetResample’s data by applying min along some dimension(s).

core.resample.DatasetResample.prod([dim, skipna])

Reduce this DatasetResample’s data by applying prod along some dimension(s).

core.resample.DatasetResample.quantile(q[, …])

Compute the qth quantile over each array in the groups and concatenate them together into a new array.

core.resample.DatasetResample.reduce(func[, …])

Reduce the items in this group by applying func along the pre-defined resampling dimension.

core.resample.DatasetResample.std([dim, skipna])

Reduce this DatasetResample’s data by applying std along some dimension(s).

core.resample.DatasetResample.sum([dim, skipna])

Reduce this DatasetResample’s data by applying sum along some dimension(s).

core.resample.DatasetResample.var([dim, skipna])

Reduce this DatasetResample’s data by applying var along some dimension(s).

core.resample.DatasetResample.where(cond[, …])

Return elements from self or other depending on cond.

core.resample.DatasetResample.dims

core.resample.DatasetResample.groups

core.rolling.DatasetRolling.argmax(**kwargs)

Reduce this object’s data windows by applying argmax along its dimension.

core.rolling.DatasetRolling.argmin(**kwargs)

Reduce this object’s data windows by applying argmin along its dimension.

core.rolling.DatasetRolling.count()

Reduce this object’s data windows by applying count along its dimension.

core.rolling.DatasetRolling.max(**kwargs)

Reduce this object’s data windows by applying max along its dimension.

core.rolling.DatasetRolling.mean(**kwargs)

Reduce this object’s data windows by applying mean along its dimension.

core.rolling.DatasetRolling.median(**kwargs)

Reduce this object’s data windows by applying median along its dimension.

core.rolling.DatasetRolling.min(**kwargs)

Reduce this object’s data windows by applying min along its dimension.

core.rolling.DatasetRolling.prod(**kwargs)

Reduce this object’s data windows by applying prod along its dimension.

core.rolling.DatasetRolling.std(**kwargs)

Reduce this object’s data windows by applying std along its dimension.

core.rolling.DatasetRolling.sum(**kwargs)

Reduce this object’s data windows by applying sum along its dimension.

core.rolling.DatasetRolling.var(**kwargs)

Reduce this object’s data windows by applying var along its dimension.

core.rolling.DatasetRolling.center

core.rolling.DatasetRolling.dim

core.rolling.DatasetRolling.min_periods

core.rolling.DatasetRolling.obj

core.rolling.DatasetRolling.rollings

core.rolling.DatasetRolling.window

core.rolling_exp.RollingExp.mean()

Exponentially weighted moving average

Dataset.argsort([axis, kind, order])

Returns the indices that would sort this array.

Dataset.astype(dtype[, order, casting, …])

Copy of the array, cast to a specified type.

Dataset.clip([min, max, out])

Return an array whose values are limited to [min, max].

Dataset.conj()

Complex-conjugate all elements.

Dataset.conjugate()

Return the complex conjugate, element-wise.

Dataset.imag

Dataset.round(*args, **kwargs)

Dataset.real

Dataset.cumsum([dim, skipna])

Apply cumsum along some dimension of Dataset.

Dataset.cumprod([dim, skipna])

Apply cumprod along some dimension of Dataset.

Dataset.rank(dim[, pct, keep_attrs])

Ranks the data.

Dataset.load_store(store[, decoder])

Create a new dataset from the contents of a backends.*DataStore object

Dataset.dump_to_store(store, **kwargs)

Store dataset contents to a backends.*DataStore object.

DataArray.ndim

DataArray.nbytes

DataArray.shape

DataArray.size

DataArray.dtype

DataArray.nbytes

DataArray.chunks

Block dimensions for this array’s data or None if it’s not a dask array.

DataArray.astype(dtype[, order, casting, …])

Copy of the array, cast to a specified type.

DataArray.item(*args)

Copy an element of an array to a standard Python scalar and return it.

DataArray.all([dim, axis])

Reduce this DataArray’s data by applying all along some dimension(s).

DataArray.any([dim, axis])

Reduce this DataArray’s data by applying any along some dimension(s).

DataArray.argmax([dim, axis, skipna])

Reduce this DataArray’s data by applying argmax along some dimension(s).

DataArray.argmin([dim, axis, skipna])

Reduce this DataArray’s data by applying argmin along some dimension(s).

DataArray.max([dim, axis, skipna])

Reduce this DataArray’s data by applying max along some dimension(s).

DataArray.min([dim, axis, skipna])

Reduce this DataArray’s data by applying min along some dimension(s).

DataArray.mean([dim, axis, skipna])

Reduce this DataArray’s data by applying mean along some dimension(s).

DataArray.median([dim, axis, skipna])

Reduce this DataArray’s data by applying median along some dimension(s).

DataArray.prod([dim, axis, skipna])

Reduce this DataArray’s data by applying prod along some dimension(s).

DataArray.sum([dim, axis, skipna])

Reduce this DataArray’s data by applying sum along some dimension(s).

DataArray.std([dim, axis, skipna])

Reduce this DataArray’s data by applying std along some dimension(s).

DataArray.var([dim, axis, skipna])

Reduce this DataArray’s data by applying var along some dimension(s).

core.coordinates.DataArrayCoordinates.get(k[,d])

core.coordinates.DataArrayCoordinates.items()

core.coordinates.DataArrayCoordinates.keys()

core.coordinates.DataArrayCoordinates.merge(other)

Merge two sets of coordinates to create a new Dataset

core.coordinates.DataArrayCoordinates.to_dataset()

core.coordinates.DataArrayCoordinates.to_index([…])

Convert all index coordinates into a pandas.Index.

core.coordinates.DataArrayCoordinates.update(other)

core.coordinates.DataArrayCoordinates.values()

core.coordinates.DataArrayCoordinates.dims

core.coordinates.DataArrayCoordinates.indexes

core.coordinates.DataArrayCoordinates.variables

core.rolling.DataArrayCoarsen.all(**kwargs)

Reduce this DataArrayCoarsen’s data by applying all along some dimension(s).

core.rolling.DataArrayCoarsen.any(**kwargs)

Reduce this DataArrayCoarsen’s data by applying any along some dimension(s).

core.rolling.DataArrayCoarsen.argmax(**kwargs)

Reduce this DataArrayCoarsen’s data by applying argmax along some dimension(s).

core.rolling.DataArrayCoarsen.argmin(**kwargs)

Reduce this DataArrayCoarsen’s data by applying argmin along some dimension(s).

core.rolling.DataArrayCoarsen.count(**kwargs)

Reduce this DataArrayCoarsen’s data by applying count along some dimension(s).

core.rolling.DataArrayCoarsen.max(**kwargs)

Reduce this DataArrayCoarsen’s data by applying max along some dimension(s).

core.rolling.DataArrayCoarsen.mean(**kwargs)

Reduce this DataArrayCoarsen’s data by applying mean along some dimension(s).

core.rolling.DataArrayCoarsen.median(**kwargs)

Reduce this DataArrayCoarsen’s data by applying median along some dimension(s).

core.rolling.DataArrayCoarsen.min(**kwargs)

Reduce this DataArrayCoarsen’s data by applying min along some dimension(s).

core.rolling.DataArrayCoarsen.prod(**kwargs)

Reduce this DataArrayCoarsen’s data by applying prod along some dimension(s).

core.rolling.DataArrayCoarsen.std(**kwargs)

Reduce this DataArrayCoarsen’s data by applying std along some dimension(s).

core.rolling.DataArrayCoarsen.sum(**kwargs)

Reduce this DataArrayCoarsen’s data by applying sum along some dimension(s).

core.rolling.DataArrayCoarsen.var(**kwargs)

Reduce this DataArrayCoarsen’s data by applying var along some dimension(s).

core.rolling.DataArrayCoarsen.boundary

core.rolling.DataArrayCoarsen.coord_func

core.rolling.DataArrayCoarsen.obj

core.rolling.DataArrayCoarsen.side

core.rolling.DataArrayCoarsen.trim_excess

core.rolling.DataArrayCoarsen.windows

core.groupby.DataArrayGroupBy.assign_coords([…])

Assign coordinates by group.

core.groupby.DataArrayGroupBy.first([…])

Return the first element of each group along the group dimension

core.groupby.DataArrayGroupBy.last([skipna, …])

Return the last element of each group along the group dimension

core.groupby.DataArrayGroupBy.fillna(value)

Fill missing values in this object by group.

core.groupby.DataArrayGroupBy.quantile(q[, …])

Compute the qth quantile over each array in the groups and concatenate them together into a new array.

core.groupby.DataArrayGroupBy.where(cond[, …])

Return elements from self or other depending on cond.

core.groupby.DataArrayGroupBy.all([dim, axis])

Reduce this DataArrayGroupBy’s data by applying all along some dimension(s).

core.groupby.DataArrayGroupBy.any([dim, axis])

Reduce this DataArrayGroupBy’s data by applying any along some dimension(s).

core.groupby.DataArrayGroupBy.argmax([dim, …])

Reduce this DataArrayGroupBy’s data by applying argmax along some dimension(s).

core.groupby.DataArrayGroupBy.argmin([dim, …])

Reduce this DataArrayGroupBy’s data by applying argmin along some dimension(s).

core.groupby.DataArrayGroupBy.count([dim, axis])

Reduce this DataArrayGroupBy’s data by applying count along some dimension(s).

core.groupby.DataArrayGroupBy.max([dim, …])

Reduce this DataArrayGroupBy’s data by applying max along some dimension(s).

core.groupby.DataArrayGroupBy.mean([dim, …])

Reduce this DataArrayGroupBy’s data by applying mean along some dimension(s).

core.groupby.DataArrayGroupBy.median([dim, …])

Reduce this DataArrayGroupBy’s data by applying median along some dimension(s).

core.groupby.DataArrayGroupBy.min([dim, …])

Reduce this DataArrayGroupBy’s data by applying min along some dimension(s).

core.groupby.DataArrayGroupBy.prod([dim, …])

Reduce this DataArrayGroupBy’s data by applying prod along some dimension(s).

core.groupby.DataArrayGroupBy.std([dim, …])

Reduce this DataArrayGroupBy’s data by applying std along some dimension(s).

core.groupby.DataArrayGroupBy.sum([dim, …])

Reduce this DataArrayGroupBy’s data by applying sum along some dimension(s).

core.groupby.DataArrayGroupBy.var([dim, …])

Reduce this DataArrayGroupBy’s data by applying var along some dimension(s).

core.groupby.DataArrayGroupBy.dims

core.groupby.DataArrayGroupBy.groups

core.resample.DataArrayResample.all([dim, axis])

Reduce this DataArrayResample’s data by applying all along some dimension(s).

core.resample.DataArrayResample.any([dim, axis])

Reduce this DataArrayResample’s data by applying any along some dimension(s).

core.resample.DataArrayResample.apply(func)

Backward compatible implementation of map

core.resample.DataArrayResample.argmax([…])

Reduce this DataArrayResample’s data by applying argmax along some dimension(s).

core.resample.DataArrayResample.argmin([…])

Reduce this DataArrayResample’s data by applying argmin along some dimension(s).

core.resample.DataArrayResample.assign_coords([…])

Assign coordinates by group.

core.resample.DataArrayResample.bfill([…])

Backward fill new values at up-sampled frequency.

core.resample.DataArrayResample.count([dim, …])

Reduce this DataArrayResample’s data by applying count along some dimension(s).

core.resample.DataArrayResample.ffill([…])

Forward fill new values at up-sampled frequency.

core.resample.DataArrayResample.fillna(value)

Fill missing values in this object by group.

core.resample.DataArrayResample.first([…])

Return the first element of each group along the group dimension

core.resample.DataArrayResample.last([…])

Return the last element of each group along the group dimension

core.resample.DataArrayResample.map(func[, …])

Apply a function to each array in the group and concatenate them together into a new array.

core.resample.DataArrayResample.max([dim, …])

Reduce this DataArrayResample’s data by applying max along some dimension(s).

core.resample.DataArrayResample.mean([dim, …])

Reduce this DataArrayResample’s data by applying mean along some dimension(s).

core.resample.DataArrayResample.median([…])

Reduce this DataArrayResample’s data by applying median along some dimension(s).

core.resample.DataArrayResample.min([dim, …])

Reduce this DataArrayResample’s data by applying min along some dimension(s).

core.resample.DataArrayResample.prod([dim, …])

Reduce this DataArrayResample’s data by applying prod along some dimension(s).

core.resample.DataArrayResample.quantile(q)

Compute the qth quantile over each array in the groups and concatenate them together into a new array.

core.resample.DataArrayResample.reduce(func)

Reduce the items in this group by applying func along some dimension(s).

core.resample.DataArrayResample.std([dim, …])

Reduce this DataArrayResample’s data by applying std along some dimension(s).

core.resample.DataArrayResample.sum([dim, …])

Reduce this DataArrayResample’s data by applying sum along some dimension(s).

core.resample.DataArrayResample.var([dim, …])

Reduce this DataArrayResample’s data by applying var along some dimension(s).

core.resample.DataArrayResample.where(cond)

Return elements from self or other depending on cond.

core.resample.DataArrayResample.dims

core.resample.DataArrayResample.groups

core.rolling.DataArrayRolling.argmax(**kwargs)

Reduce this object’s data windows by applying argmax along its dimension.

core.rolling.DataArrayRolling.argmin(**kwargs)

Reduce this object’s data windows by applying argmin along its dimension.

core.rolling.DataArrayRolling.count()

Reduce this object’s data windows by applying count along its dimension.

core.rolling.DataArrayRolling.max(**kwargs)

Reduce this object’s data windows by applying max along its dimension.

core.rolling.DataArrayRolling.mean(**kwargs)

Reduce this object’s data windows by applying mean along its dimension.

core.rolling.DataArrayRolling.median(**kwargs)

Reduce this object’s data windows by applying median along its dimension.

core.rolling.DataArrayRolling.min(**kwargs)

Reduce this object’s data windows by applying min along its dimension.

core.rolling.DataArrayRolling.prod(**kwargs)

Reduce this object’s data windows by applying prod along its dimension.

core.rolling.DataArrayRolling.std(**kwargs)

Reduce this object’s data windows by applying std along its dimension.

core.rolling.DataArrayRolling.sum(**kwargs)

Reduce this object’s data windows by applying sum along its dimension.

core.rolling.DataArrayRolling.var(**kwargs)

Reduce this object’s data windows by applying var along its dimension.

core.rolling.DataArrayRolling.center

core.rolling.DataArrayRolling.dim

core.rolling.DataArrayRolling.min_periods

core.rolling.DataArrayRolling.obj

core.rolling.DataArrayRolling.window

core.rolling.DataArrayRolling.window_labels

DataArray.argsort([axis, kind, order])

Returns the indices that would sort this array.

DataArray.clip([min, max, out])

Return an array whose values are limited to [min, max].

DataArray.conj()

Complex-conjugate all elements.

DataArray.conjugate()

Return the complex conjugate, element-wise.

DataArray.imag

DataArray.searchsorted(v[, side, sorter])

Find indices where elements of v should be inserted in a to maintain order.

DataArray.round(*args, **kwargs)

DataArray.real

DataArray.T

DataArray.cumsum([dim, axis, skipna])

Apply cumsum along some dimension of DataArray.

DataArray.cumprod([dim, axis, skipna])

Apply cumprod along some dimension of DataArray.

DataArray.rank(dim[, pct, keep_attrs])

Ranks the data.

core.accessor_dt.DatetimeAccessor.ceil(freq)

Round timestamps upward to specified frequency resolution.

core.accessor_dt.DatetimeAccessor.floor(freq)

Round timestamps downward to specified frequency resolution.

core.accessor_dt.DatetimeAccessor.round(freq)

Round timestamps to specified frequency resolution.

core.accessor_dt.DatetimeAccessor.strftime(…)

Return an array of formatted strings specified by date_format, which supports the same string format as the python standard library.

core.accessor_dt.DatetimeAccessor.day

The days of the datetime

core.accessor_dt.DatetimeAccessor.dayofweek

The day of the week with Monday=0, Sunday=6

core.accessor_dt.DatetimeAccessor.dayofyear

The ordinal day of the year

core.accessor_dt.DatetimeAccessor.days_in_month

The number of days in the month

core.accessor_dt.DatetimeAccessor.daysinmonth

The number of days in the month

core.accessor_dt.DatetimeAccessor.hour

The hours of the datetime

core.accessor_dt.DatetimeAccessor.microsecond

The microseconds of the datetime

core.accessor_dt.DatetimeAccessor.minute

The minutes of the datetime

core.accessor_dt.DatetimeAccessor.month

The month as January=1, December=12

core.accessor_dt.DatetimeAccessor.nanosecond

The nanoseconds of the datetime

core.accessor_dt.DatetimeAccessor.quarter

The quarter of the date

core.accessor_dt.DatetimeAccessor.season

Season of the year

core.accessor_dt.DatetimeAccessor.second

The seconds of the datetime

core.accessor_dt.DatetimeAccessor.time

Timestamps corresponding to datetimes

core.accessor_dt.DatetimeAccessor.week

The week ordinal of the year

core.accessor_dt.DatetimeAccessor.weekday

The day of the week with Monday=0, Sunday=6

core.accessor_dt.DatetimeAccessor.weekday_name

The name of day in a week

core.accessor_dt.DatetimeAccessor.weekofyear

The week ordinal of the year

core.accessor_dt.DatetimeAccessor.year

The year of the datetime

core.accessor_str.StringAccessor.capitalize()

Convert strings in the array to be capitalized.

core.accessor_str.StringAccessor.center(width)

Filling left and right side of strings in the array with an additional character.

core.accessor_str.StringAccessor.contains(pat)

Test if pattern or regex is contained within a string of the array.

core.accessor_str.StringAccessor.count(pat)

Count occurrences of pattern in each string of the array.

core.accessor_str.StringAccessor.decode(encoding)

Decode character string in the array using indicated encoding.

core.accessor_str.StringAccessor.encode(encoding)

Encode character string in the array using indicated encoding.

core.accessor_str.StringAccessor.endswith(pat)

Test if the end of each string element matches a pattern.

core.accessor_str.StringAccessor.find(sub[, …])

Return lowest or highest indexes in each strings in the array where the substring is fully contained between [start:end].

core.accessor_str.StringAccessor.get(i)

Extract element from indexable in each element in the array.

core.accessor_str.StringAccessor.index(sub)

Return lowest or highest indexes in each strings where the substring is fully contained between [start:end].

core.accessor_str.StringAccessor.isalnum()

Check whether all characters in each string are alphanumeric.

core.accessor_str.StringAccessor.isalpha()

Check whether all characters in each string are alphabetic.

core.accessor_str.StringAccessor.isdecimal()

Check whether all characters in each string are decimal.

core.accessor_str.StringAccessor.isdigit()

Check whether all characters in each string are digits.

core.accessor_str.StringAccessor.islower()

Check whether all characters in each string are lowercase.

core.accessor_str.StringAccessor.isnumeric()

Check whether all characters in each string are numeric.

core.accessor_str.StringAccessor.isspace()

Check whether all characters in each string are spaces.

core.accessor_str.StringAccessor.istitle()

Check whether all characters in each string are titlecase.

core.accessor_str.StringAccessor.isupper()

Check whether all characters in each string are uppercase.

core.accessor_str.StringAccessor.len()

Compute the length of each element in the array.

core.accessor_str.StringAccessor.ljust(width)

Filling right side of strings in the array with an additional character.

core.accessor_str.StringAccessor.lower()

Convert strings in the array to lowercase.

core.accessor_str.StringAccessor.lstrip([…])

Remove leading and trailing characters.

core.accessor_str.StringAccessor.match(pat)

Determine if each string matches a regular expression.

core.accessor_str.StringAccessor.pad(width)

Pad strings in the array up to width.

core.accessor_str.StringAccessor.repeat(repeats)

Duplicate each string in the array.

core.accessor_str.StringAccessor.replace(…)

Replace occurrences of pattern/regex in the array with some string.

core.accessor_str.StringAccessor.rfind(sub)

Return highest indexes in each strings in the array where the substring is fully contained between [start:end].

core.accessor_str.StringAccessor.rindex(sub)

Return highest indexes in each strings where the substring is fully contained between [start:end].

core.accessor_str.StringAccessor.rjust(width)

Filling left side of strings in the array with an additional character.

core.accessor_str.StringAccessor.rstrip([…])

Remove leading and trailing characters.

core.accessor_str.StringAccessor.slice([…])

Slice substrings from each element in the array.

core.accessor_str.StringAccessor.slice_replace([…])

Replace a positional slice of a string with another value.

core.accessor_str.StringAccessor.startswith(pat)

Test if the start of each string element matches a pattern.

core.accessor_str.StringAccessor.strip([…])

Remove leading and trailing characters.

core.accessor_str.StringAccessor.swapcase()

Convert strings in the array to be swapcased.

core.accessor_str.StringAccessor.title()

Convert strings in the array to titlecase.

core.accessor_str.StringAccessor.translate(table)

Map all characters in the string through the given mapping table.

core.accessor_str.StringAccessor.upper()

Convert strings in the array to uppercase.

core.accessor_str.StringAccessor.wrap(width, …)

Wrap long strings in the array to be formatted in paragraphs with length less than a given width.

core.accessor_str.StringAccessor.zfill(width)

Pad strings in the array by prepending ‘0’ characters.

Variable.all([dim, axis])

Reduce this Variable’s data by applying all along some dimension(s).

Variable.any([dim, axis])

Reduce this Variable’s data by applying any along some dimension(s).

Variable.argmax([dim, axis, skipna])

Reduce this Variable’s data by applying argmax along some dimension(s).

Variable.argmin([dim, axis, skipna])

Reduce this Variable’s data by applying argmin along some dimension(s).

Variable.argsort([axis, kind, order])

Returns the indices that would sort this array.

Variable.astype(dtype[, order, casting, …])

Copy of the array, cast to a specified type.

Variable.broadcast_equals(other[, equiv])

True if two Variables have the values after being broadcast against each other; otherwise False.

Variable.chunk([chunks, name, lock])

Coerce this array’s data into a dask arrays with the given chunks.

Variable.clip([min, max, out])

Return an array whose values are limited to [min, max].

Variable.coarsen(windows, func[, boundary, side])

Apply reduction function.

Variable.compute(**kwargs)

Manually trigger loading of this variable’s data from disk or a remote source into memory and return a new variable.

Variable.concat(variables[, dim, positions, …])

Concatenate variables along a new or existing dimension.

Variable.conj()

Complex-conjugate all elements.

Variable.conjugate()

Return the complex conjugate, element-wise.

Variable.copy([deep, data])

Returns a copy of this object.

Variable.count([dim, axis])

Reduce this Variable’s data by applying count along some dimension(s).

Variable.cumprod([dim, axis, skipna])

Apply cumprod along some dimension of Variable.

Variable.cumsum([dim, axis, skipna])

Apply cumsum along some dimension of Variable.

Variable.equals(other[, equiv])

True if two Variables have the same dimensions and values; otherwise False.

Variable.fillna(value)

Variable.get_axis_num(dim)

Return axis number(s) corresponding to dimension(s) in this array.

Variable.identical(other[, equiv])

Like equals, but also checks attributes.

Variable.isel([indexers])

Return a new array indexed along the specified dimension(s).

Variable.isnull(*args, **kwargs)

Variable.item(*args)

Copy an element of an array to a standard Python scalar and return it.

Variable.load(**kwargs)

Manually trigger loading of this variable’s data from disk or a remote source into memory and return this variable.

Variable.max([dim, axis, skipna])

Reduce this Variable’s data by applying max along some dimension(s).

Variable.mean([dim, axis, skipna])

Reduce this Variable’s data by applying mean along some dimension(s).

Variable.median([dim, axis, skipna])

Reduce this Variable’s data by applying median along some dimension(s).

Variable.min([dim, axis, skipna])

Reduce this Variable’s data by applying min along some dimension(s).

Variable.no_conflicts(other[, equiv])

True if the intersection of two Variable’s non-null data is equal; otherwise false.

Variable.notnull(*args, **kwargs)

Variable.prod([dim, axis, skipna])

Reduce this Variable’s data by applying prod along some dimension(s).

Variable.quantile(q[, dim, interpolation, …])

Compute the qth quantile of the data along the specified dimension.

Variable.rank(dim[, pct])

Ranks the data.

Variable.reduce(func[, dim, axis, …])

Reduce this array by applying func along some dimension(s).

Variable.roll([shifts])

Return a new Variable with rolld data.

Variable.rolling_window(dim, window, window_dim)

Make a rolling_window along dim and add a new_dim to the last place.

Variable.round(*args, **kwargs)

Variable.searchsorted(v[, side, sorter])

Find indices where elements of v should be inserted in a to maintain order.

Variable.set_dims(dims[, shape])

Return a new variable with given set of dimensions.

Variable.shift([shifts, fill_value])

Return a new Variable with shifted data.

Variable.squeeze([dim])

Return a new object with squeezed data.

Variable.stack([dimensions])

Stack any number of existing dimensions into a single new dimension.

Variable.std([dim, axis, skipna])

Reduce this Variable’s data by applying std along some dimension(s).

Variable.sum([dim, axis, skipna])

Reduce this Variable’s data by applying sum along some dimension(s).

Variable.to_base_variable()

Return this variable as a base xarray.Variable

Variable.to_coord()

to_coord has been deprecated.

Variable.to_dict([data])

Dictionary representation of variable.

Variable.to_index()

Convert this variable to a pandas.Index

Variable.to_index_variable()

Return this variable as an xarray.IndexVariable

Variable.to_variable()

to_variable has been deprecated.

Variable.transpose(*dims)

Return a new Variable object with transposed dimensions.

Variable.unstack([dimensions])

Unstack an existing dimension into multiple new dimensions.

Variable.var([dim, axis, skipna])

Reduce this Variable’s data by applying var along some dimension(s).

Variable.where(cond[, other])

Variable.T

Variable.attrs

Dictionary of local attributes on this variable.

Variable.chunks

Block dimensions for this array’s data or None if it’s not a dask array.

Variable.data

Variable.dims

Tuple of dimension names with which this variable is associated.

Variable.dtype

Variable.encoding

Dictionary of encodings on this variable.

Variable.imag

Variable.nbytes

Variable.ndim

Variable.real

Variable.shape

Variable.size

Variable.sizes

Ordered mapping from dimension names to lengths.

Variable.values

The variable’s data as a numpy.ndarray

IndexVariable.all([dim, axis])

Reduce this Variable’s data by applying all along some dimension(s).

IndexVariable.any([dim, axis])

Reduce this Variable’s data by applying any along some dimension(s).

IndexVariable.argmax([dim, axis, skipna])

Reduce this Variable’s data by applying argmax along some dimension(s).

IndexVariable.argmin([dim, axis, skipna])

Reduce this Variable’s data by applying argmin along some dimension(s).

IndexVariable.argsort([axis, kind, order])

Returns the indices that would sort this array.

IndexVariable.astype(dtype[, order, …])

Copy of the array, cast to a specified type.

IndexVariable.broadcast_equals(other[, equiv])

True if two Variables have the values after being broadcast against each other; otherwise False.

IndexVariable.chunk([chunks, name, lock])

Coerce this array’s data into a dask arrays with the given chunks.

IndexVariable.clip([min, max, out])

Return an array whose values are limited to [min, max].

IndexVariable.coarsen(windows, func[, …])

Apply reduction function.

IndexVariable.compute(**kwargs)

Manually trigger loading of this variable’s data from disk or a remote source into memory and return a new variable.

IndexVariable.concat(variables[, dim, …])

Specialized version of Variable.concat for IndexVariable objects.

IndexVariable.conj()

Complex-conjugate all elements.

IndexVariable.conjugate()

Return the complex conjugate, element-wise.

IndexVariable.copy([deep, data])

Returns a copy of this object.

IndexVariable.count([dim, axis])

Reduce this Variable’s data by applying count along some dimension(s).

IndexVariable.cumprod([dim, axis, skipna])

Apply cumprod along some dimension of Variable.

IndexVariable.cumsum([dim, axis, skipna])

Apply cumsum along some dimension of Variable.

IndexVariable.equals(other[, equiv])

True if two Variables have the same dimensions and values; otherwise False.

IndexVariable.fillna(value)

IndexVariable.get_axis_num(dim)

Return axis number(s) corresponding to dimension(s) in this array.

IndexVariable.get_level_variable(level)

Return a new IndexVariable from a given MultiIndex level.

IndexVariable.identical(other[, equiv])

Like equals, but also checks attributes.

IndexVariable.isel([indexers])

Return a new array indexed along the specified dimension(s).

IndexVariable.isnull(*args, **kwargs)

IndexVariable.item(*args)

Copy an element of an array to a standard Python scalar and return it.

IndexVariable.load()

Manually trigger loading of this variable’s data from disk or a remote source into memory and return this variable.

IndexVariable.max([dim, axis, skipna])

Reduce this Variable’s data by applying max along some dimension(s).

IndexVariable.mean([dim, axis, skipna])

Reduce this Variable’s data by applying mean along some dimension(s).

IndexVariable.median([dim, axis, skipna])

Reduce this Variable’s data by applying median along some dimension(s).

IndexVariable.min([dim, axis, skipna])

Reduce this Variable’s data by applying min along some dimension(s).

IndexVariable.no_conflicts(other[, equiv])

True if the intersection of two Variable’s non-null data is equal; otherwise false.

IndexVariable.notnull(*args, **kwargs)

IndexVariable.prod([dim, axis, skipna])

Reduce this Variable’s data by applying prod along some dimension(s).

IndexVariable.quantile(q[, dim, …])

Compute the qth quantile of the data along the specified dimension.

IndexVariable.rank(dim[, pct])

Ranks the data.

IndexVariable.reduce(func[, dim, axis, …])

Reduce this array by applying func along some dimension(s).

IndexVariable.roll([shifts])

Return a new Variable with rolld data.

IndexVariable.rolling_window(dim, window, …)

Make a rolling_window along dim and add a new_dim to the last place.

IndexVariable.round(*args, **kwargs)

IndexVariable.searchsorted(v[, side, sorter])

Find indices where elements of v should be inserted in a to maintain order.

IndexVariable.set_dims(dims[, shape])

Return a new variable with given set of dimensions.

IndexVariable.shift([shifts, fill_value])

Return a new Variable with shifted data.

IndexVariable.squeeze([dim])

Return a new object with squeezed data.

IndexVariable.stack([dimensions])

Stack any number of existing dimensions into a single new dimension.

IndexVariable.std([dim, axis, skipna])

Reduce this Variable’s data by applying std along some dimension(s).

IndexVariable.sum([dim, axis, skipna])

Reduce this Variable’s data by applying sum along some dimension(s).

IndexVariable.to_base_variable()

Return this variable as a base xarray.Variable

IndexVariable.to_coord()

to_coord has been deprecated.

IndexVariable.to_dict([data])

Dictionary representation of variable.

IndexVariable.to_index()

Convert this variable to a pandas.Index

IndexVariable.to_index_variable()

Return this variable as an xarray.IndexVariable

IndexVariable.to_variable()

to_variable has been deprecated.

IndexVariable.transpose(*dims)

Return a new Variable object with transposed dimensions.

IndexVariable.unstack([dimensions])

Unstack an existing dimension into multiple new dimensions.

IndexVariable.var([dim, axis, skipna])

Reduce this Variable’s data by applying var along some dimension(s).

IndexVariable.where(cond[, other])

IndexVariable.T

IndexVariable.attrs

Dictionary of local attributes on this variable.

IndexVariable.chunks

Block dimensions for this array’s data or None if it’s not a dask array.

IndexVariable.data

IndexVariable.dims

Tuple of dimension names with which this variable is associated.

IndexVariable.dtype

IndexVariable.encoding

Dictionary of encodings on this variable.

IndexVariable.imag

IndexVariable.level_names

Return MultiIndex level names or None if this IndexVariable has no MultiIndex.

IndexVariable.name

IndexVariable.nbytes

IndexVariable.ndim

IndexVariable.real

IndexVariable.shape

IndexVariable.size

IndexVariable.sizes

Ordered mapping from dimension names to lengths.

IndexVariable.values

The variable’s data as a numpy.ndarray

ufuncs.angle

xarray specific variant of numpy.angle.

ufuncs.arccos

xarray specific variant of numpy.arccos.

ufuncs.arccosh

xarray specific variant of numpy.arccosh.

ufuncs.arcsin

xarray specific variant of numpy.arcsin.

ufuncs.arcsinh

xarray specific variant of numpy.arcsinh.

ufuncs.arctan

xarray specific variant of numpy.arctan.

ufuncs.arctan2

xarray specific variant of numpy.arctan2.

ufuncs.arctanh

xarray specific variant of numpy.arctanh.

ufuncs.ceil

xarray specific variant of numpy.ceil.

ufuncs.conj

xarray specific variant of numpy.conj.

ufuncs.copysign

xarray specific variant of numpy.copysign.

ufuncs.cos

xarray specific variant of numpy.cos.

ufuncs.cosh

xarray specific variant of numpy.cosh.

ufuncs.deg2rad

xarray specific variant of numpy.deg2rad.

ufuncs.degrees

xarray specific variant of numpy.degrees.

ufuncs.exp

xarray specific variant of numpy.exp.

ufuncs.expm1

xarray specific variant of numpy.expm1.

ufuncs.fabs

xarray specific variant of numpy.fabs.

ufuncs.fix

xarray specific variant of numpy.fix.

ufuncs.floor

xarray specific variant of numpy.floor.

ufuncs.fmax

xarray specific variant of numpy.fmax.

ufuncs.fmin

xarray specific variant of numpy.fmin.

ufuncs.fmod

xarray specific variant of numpy.fmod.

ufuncs.fmod

xarray specific variant of numpy.fmod.

ufuncs.frexp

xarray specific variant of numpy.frexp.

ufuncs.hypot

xarray specific variant of numpy.hypot.

ufuncs.imag

xarray specific variant of numpy.imag.

ufuncs.iscomplex

xarray specific variant of numpy.iscomplex.

ufuncs.isfinite

xarray specific variant of numpy.isfinite.

ufuncs.isinf

xarray specific variant of numpy.isinf.

ufuncs.isnan

xarray specific variant of numpy.isnan.

ufuncs.isreal

xarray specific variant of numpy.isreal.

ufuncs.ldexp

xarray specific variant of numpy.ldexp.

ufuncs.log

xarray specific variant of numpy.log.

ufuncs.log10

xarray specific variant of numpy.log10.

ufuncs.log1p

xarray specific variant of numpy.log1p.

ufuncs.log2

xarray specific variant of numpy.log2.

ufuncs.logaddexp

xarray specific variant of numpy.logaddexp.

ufuncs.logaddexp2

xarray specific variant of numpy.logaddexp2.

ufuncs.logical_and

xarray specific variant of numpy.logical_and.

ufuncs.logical_not

xarray specific variant of numpy.logical_not.

ufuncs.logical_or

xarray specific variant of numpy.logical_or.

ufuncs.logical_xor

xarray specific variant of numpy.logical_xor.

ufuncs.maximum

xarray specific variant of numpy.maximum.

ufuncs.minimum

xarray specific variant of numpy.minimum.

ufuncs.nextafter

xarray specific variant of numpy.nextafter.

ufuncs.rad2deg

xarray specific variant of numpy.rad2deg.

ufuncs.radians

xarray specific variant of numpy.radians.

ufuncs.real

xarray specific variant of numpy.real.

ufuncs.rint

xarray specific variant of numpy.rint.

ufuncs.sign

xarray specific variant of numpy.sign.

ufuncs.signbit

xarray specific variant of numpy.signbit.

ufuncs.sin

xarray specific variant of numpy.sin.

ufuncs.sinh

xarray specific variant of numpy.sinh.

ufuncs.sqrt

xarray specific variant of numpy.sqrt.

ufuncs.square

xarray specific variant of numpy.square.

ufuncs.tan

xarray specific variant of numpy.tan.

ufuncs.tanh

xarray specific variant of numpy.tanh.

ufuncs.trunc

xarray specific variant of numpy.trunc.

plot.FacetGrid.map_dataarray(func, x, y, …)

Apply a plotting function to a 2d facet’s subset of the data.

plot.FacetGrid.set_titles([template, …])

Draw titles either above each facet or on the grid margins.

plot.FacetGrid.set_ticks([max_xticks, …])

Set and control tick behavior

plot.FacetGrid.map(func, *args, **kwargs)

Apply a plotting function to each facet’s subset of the data.

CFTimeIndex.all(*args, **kwargs)

Return whether all elements are True.

CFTimeIndex.any(*args, **kwargs)

Return whether any element is True.

CFTimeIndex.append(other)

Append a collection of Index options together.

CFTimeIndex.argmax([axis, skipna])

Return an ndarray of the maximum argument indexer.

CFTimeIndex.argmin([axis, skipna])

Return a ndarray of the minimum argument indexer.

CFTimeIndex.argsort(*args, **kwargs)

Return the integer indices that would sort the index.

CFTimeIndex.asof(label)

Return the label from the index, or, if not present, the previous one.

CFTimeIndex.asof_locs(where, mask)

Find the locations (indices) of the labels from the index for every entry in the where argument.

CFTimeIndex.astype(dtype[, copy])

Create an Index with values cast to dtypes.

CFTimeIndex.contains(key)

Needed for .loc based partial-string indexing

CFTimeIndex.copy([name, deep, dtype])

Make a copy of this object.

CFTimeIndex.delete(loc)

Make new Index with passed location(-s) deleted.

CFTimeIndex.difference(other[, sort])

Return a new Index with elements from the index that are not in other.

CFTimeIndex.drop(labels[, errors])

Make new Index with passed list of labels deleted.

CFTimeIndex.drop_duplicates([keep])

Return Index with duplicate values removed.

CFTimeIndex.droplevel([level])

Return index with requested level(s) removed.

CFTimeIndex.dropna([how])

Return Index without NA/NaN values

CFTimeIndex.duplicated([keep])

Indicate duplicate index values.

CFTimeIndex.equals(other)

Determine if two Index objects contain the same elements.

CFTimeIndex.factorize([sort, na_sentinel])

Encode the object as an enumerated type or categorical variable.

CFTimeIndex.fillna([value, downcast])

Fill NA/NaN values with the specified value

CFTimeIndex.format([name, formatter])

Render a string representation of the Index.

CFTimeIndex.get_indexer(target[, method, …])

Compute indexer and mask for new index given the current index.

CFTimeIndex.get_indexer_for(target, **kwargs)

Guaranteed return of an indexer even when non-unique.

CFTimeIndex.get_indexer_non_unique(target)

Compute indexer and mask for new index given the current index.

CFTimeIndex.get_level_values(level)

Return an Index of values for requested level.

CFTimeIndex.get_loc(key[, method, tolerance])

Adapted from pandas.tseries.index.DatetimeIndex.get_loc

CFTimeIndex.get_slice_bound(label, side, kind)

Calculate slice bound that corresponds to given label.

CFTimeIndex.get_value(series, key)

Adapted from pandas.tseries.index.DatetimeIndex.get_value

CFTimeIndex.groupby(values)

Group the index labels by a given array of values.

CFTimeIndex.holds_integer()

Whether the type is an integer type.

CFTimeIndex.identical(other)

Similar to equals, but check that other comparable attributes are also equal.

CFTimeIndex.insert(loc, item)

Make new Index inserting new item at location.

CFTimeIndex.intersection(other[, sort])

Form the intersection of two Index objects.

CFTimeIndex.is_(other)

More flexible, faster check like is but that works through views.

CFTimeIndex.is_boolean()

CFTimeIndex.is_categorical()

Check if the Index holds categorical data.

CFTimeIndex.is_floating()

CFTimeIndex.is_integer()

CFTimeIndex.is_interval()

CFTimeIndex.is_mixed()

CFTimeIndex.is_numeric()

CFTimeIndex.is_object()

CFTimeIndex.is_type_compatible(kind)

Whether the index type is compatible with the provided type.

CFTimeIndex.isin(values[, level])

Return a boolean array where the index values are in values.

CFTimeIndex.isna()

Detect missing values.

CFTimeIndex.isnull()

Detect missing values.

CFTimeIndex.item()

Return the first element of the underlying data as a python scalar.

CFTimeIndex.join(other[, how, level, …])

Compute join_index and indexers to conform data structures to the new index.

CFTimeIndex.map(mapper[, na_action])

Map values using input correspondence (a dict, Series, or function).

CFTimeIndex.max([axis, skipna])

Return the maximum value of the Index.

CFTimeIndex.memory_usage([deep])

Memory usage of the values

CFTimeIndex.min([axis, skipna])

Return the minimum value of the Index.

CFTimeIndex.notna()

Detect existing (non-missing) values.

CFTimeIndex.notnull()

Detect existing (non-missing) values.

CFTimeIndex.nunique([dropna])

Return number of unique elements in the object.

CFTimeIndex.putmask(mask, value)

Return a new Index of the values set with the mask.

CFTimeIndex.ravel([order])

Return an ndarray of the flattened values of the underlying data.

CFTimeIndex.reindex(target[, method, level, …])

Create index with target’s values (move/add/delete values as necessary).

CFTimeIndex.rename(name[, inplace])

Alter Index or MultiIndex name.

CFTimeIndex.repeat(repeats[, axis])

Repeat elements of a Index.

CFTimeIndex.searchsorted(value[, side, sorter])

Find indices where elements should be inserted to maintain order.

CFTimeIndex.set_names(names[, level, inplace])

Set Index or MultiIndex name.

CFTimeIndex.set_value(arr, key, value)

Fast lookup of value from 1-dimensional ndarray.

CFTimeIndex.shift(n, freq)

Shift the CFTimeIndex a multiple of the given frequency.

CFTimeIndex.slice_indexer([start, end, …])

For an ordered or unique index, compute the slice indexer for input labels and step.

CFTimeIndex.slice_locs([start, end, step, kind])

Compute slice locations for input labels.

CFTimeIndex.sort(*args, **kwargs)

Use sort_values instead.

CFTimeIndex.sort_values([return_indexer, …])

Return a sorted copy of the index.

CFTimeIndex.sortlevel([level, ascending, …])

For internal compatibility with with the Index API.

CFTimeIndex.strftime(date_format)

Return an Index of formatted strings specified by date_format, which supports the same string format as the python standard library.

CFTimeIndex.symmetric_difference(other[, …])

Compute the symmetric difference of two Index objects.

CFTimeIndex.take(indices[, axis, …])

Return a new Index of the values selected by the indices.

CFTimeIndex.to_datetimeindex([unsafe])

If possible, convert this index to a pandas.DatetimeIndex.

CFTimeIndex.to_flat_index()

Identity method.

CFTimeIndex.to_frame([index, name])

Create a DataFrame with a column containing the Index.

CFTimeIndex.to_list()

Return a list of the values.

CFTimeIndex.to_native_types([slicer])

Format specified values of self and return them.

CFTimeIndex.to_numpy([dtype, copy])

A NumPy ndarray representing the values in this Series or Index.

CFTimeIndex.to_series([index, name])

Create a Series with both index and values equal to the index keys useful with map for returning an indexer based on an index.

CFTimeIndex.tolist()

Return a list of the values.

CFTimeIndex.transpose(*args, **kwargs)

Return the transpose, which is by definition self.

CFTimeIndex.union(other[, sort])

Form the union of two Index objects.

CFTimeIndex.unique([level])

Return unique values in the index.

CFTimeIndex.value_counts([normalize, sort, …])

Return a Series containing counts of unique values.

CFTimeIndex.view([cls])

CFTimeIndex.where(cond[, other])

Return an Index of same shape as self and whose corresponding entries are from self where cond is True and otherwise are from other.

CFTimeIndex.T

Return the transpose, which is by definition self.

CFTimeIndex.array

The ExtensionArray of the data backing this Series or Index.

CFTimeIndex.asi8

Convert to integers with units of microseconds since 1970-01-01.

CFTimeIndex.date_type

CFTimeIndex.day

The days of the datetime

CFTimeIndex.dayofweek

The day of week of the datetime

CFTimeIndex.dayofyear

The ordinal day of year of the datetime

CFTimeIndex.dtype

Return the dtype object of the underlying data.

CFTimeIndex.empty

CFTimeIndex.has_duplicates

CFTimeIndex.hasnans

Return if I have any nans; enables various perf speedups.

CFTimeIndex.hour

The hours of the datetime

CFTimeIndex.inferred_type

Return a string of the type inferred from the values.

CFTimeIndex.is_all_dates

CFTimeIndex.is_monotonic

Alias for is_monotonic_increasing.

CFTimeIndex.is_monotonic_increasing

Return if the index is monotonic increasing (only equal or increasing) values.

CFTimeIndex.is_monotonic_decreasing

Return if the index is monotonic decreasing (only equal or decreasing) values.

CFTimeIndex.is_unique

Return if the index has unique values.

CFTimeIndex.microsecond

The microseconds of the datetime

CFTimeIndex.minute

The minutes of the datetime

CFTimeIndex.month

The month of the datetime

CFTimeIndex.name

CFTimeIndex.names

CFTimeIndex.nbytes

Return the number of bytes in the underlying data.

CFTimeIndex.ndim

Number of dimensions of the underlying data, by definition 1.

CFTimeIndex.nlevels

Number of levels.

CFTimeIndex.second

The seconds of the datetime

CFTimeIndex.shape

Return a tuple of the shape of the underlying data.

CFTimeIndex.size

Return the number of elements in the underlying data.

CFTimeIndex.values

Return an array representing the data in the Index.

CFTimeIndex.year

The year of the datetime

backends.NetCDF4DataStore.close(**kwargs)

backends.NetCDF4DataStore.encode(variables, …)

Encode the variables and attributes in this store

backends.NetCDF4DataStore.encode_attribute(a)

encode one attribute

backends.NetCDF4DataStore.encode_variable(…)

encode one variable

backends.NetCDF4DataStore.get(k[,d])

backends.NetCDF4DataStore.get_attrs()

backends.NetCDF4DataStore.get_dimensions()

backends.NetCDF4DataStore.get_encoding()

backends.NetCDF4DataStore.get_variables()

backends.NetCDF4DataStore.items()

backends.NetCDF4DataStore.keys()

backends.NetCDF4DataStore.load()

This loads the variables and attributes simultaneously.

backends.NetCDF4DataStore.open(filename[, …])

backends.NetCDF4DataStore.open_store_variable(…)

backends.NetCDF4DataStore.prepare_variable(…)

backends.NetCDF4DataStore.set_attribute(key, …)

backends.NetCDF4DataStore.set_attributes(…)

This provides a centralized method to set the dataset attributes on the data store.

backends.NetCDF4DataStore.set_dimension(…)

backends.NetCDF4DataStore.set_dimensions(…)

This provides a centralized method to set the dimensions on the data store.

backends.NetCDF4DataStore.set_variable(k, v)

backends.NetCDF4DataStore.set_variables(…)

This provides a centralized method to set the variables on the data store.

backends.NetCDF4DataStore.store(variables, …)

Top level method for putting data on this store, this method:

backends.NetCDF4DataStore.store_dataset(dataset)

in stores, variables are all variables AND coordinates in xarray.Dataset variables are variables NOT coordinates, so here we pass the whole dataset in instead of doing dataset.variables

backends.NetCDF4DataStore.sync()

backends.NetCDF4DataStore.values()

backends.NetCDF4DataStore.attrs

backends.NetCDF4DataStore.autoclose

backends.NetCDF4DataStore.dimensions

backends.NetCDF4DataStore.ds

backends.NetCDF4DataStore.format

backends.NetCDF4DataStore.is_remote

backends.NetCDF4DataStore.lock

backends.NetCDF4DataStore.variables

backends.H5NetCDFStore.close(**kwargs)

backends.H5NetCDFStore.encode(variables, …)

Encode the variables and attributes in this store

backends.H5NetCDFStore.encode_attribute(a)

encode one attribute

backends.H5NetCDFStore.encode_variable(variable)

encode one variable

backends.H5NetCDFStore.get(k[,d])

backends.H5NetCDFStore.get_attrs()

backends.H5NetCDFStore.get_dimensions()

backends.H5NetCDFStore.get_encoding()

backends.H5NetCDFStore.get_variables()

backends.H5NetCDFStore.items()

backends.H5NetCDFStore.keys()

backends.H5NetCDFStore.load()

This loads the variables and attributes simultaneously.

backends.H5NetCDFStore.open_store_variable(…)

backends.H5NetCDFStore.prepare_variable(…)

backends.H5NetCDFStore.set_attribute(key, value)

backends.H5NetCDFStore.set_attributes(attributes)

This provides a centralized method to set the dataset attributes on the data store.

backends.H5NetCDFStore.set_dimension(name, …)

backends.H5NetCDFStore.set_dimensions(variables)

This provides a centralized method to set the dimensions on the data store.

backends.H5NetCDFStore.set_variable(k, v)

backends.H5NetCDFStore.set_variables(…[, …])

This provides a centralized method to set the variables on the data store.

backends.H5NetCDFStore.store(variables, …)

Top level method for putting data on this store, this method:

backends.H5NetCDFStore.store_dataset(dataset)

in stores, variables are all variables AND coordinates in xarray.Dataset variables are variables NOT coordinates, so here we pass the whole dataset in instead of doing dataset.variables

backends.H5NetCDFStore.sync()

backends.H5NetCDFStore.values()

backends.H5NetCDFStore.attrs

backends.H5NetCDFStore.dimensions

backends.H5NetCDFStore.ds

backends.H5NetCDFStore.variables

backends.PydapDataStore.close()

backends.PydapDataStore.get(k[,d])

backends.PydapDataStore.get_attrs()

backends.PydapDataStore.get_dimensions()

backends.PydapDataStore.get_encoding()

backends.PydapDataStore.get_variables()

backends.PydapDataStore.items()

backends.PydapDataStore.keys()

backends.PydapDataStore.load()

This loads the variables and attributes simultaneously.

backends.PydapDataStore.open(url[, session])

backends.PydapDataStore.open_store_variable(var)

backends.PydapDataStore.values()

backends.PydapDataStore.attrs

backends.PydapDataStore.dimensions

backends.PydapDataStore.variables

backends.ScipyDataStore.close()

backends.ScipyDataStore.encode(variables, …)

Encode the variables and attributes in this store

backends.ScipyDataStore.encode_attribute(a)

encode one attribute

backends.ScipyDataStore.encode_variable(variable)

encode one variable

backends.ScipyDataStore.get(k[,d])

backends.ScipyDataStore.get_attrs()

backends.ScipyDataStore.get_dimensions()

backends.ScipyDataStore.get_encoding()

backends.ScipyDataStore.get_variables()

backends.ScipyDataStore.items()

backends.ScipyDataStore.keys()

backends.ScipyDataStore.load()

This loads the variables and attributes simultaneously.

backends.ScipyDataStore.open_store_variable(…)

backends.ScipyDataStore.prepare_variable(…)

backends.ScipyDataStore.set_attribute(key, value)

backends.ScipyDataStore.set_attributes(…)

This provides a centralized method to set the dataset attributes on the data store.

backends.ScipyDataStore.set_dimension(name, …)

backends.ScipyDataStore.set_dimensions(variables)

This provides a centralized method to set the dimensions on the data store.

backends.ScipyDataStore.set_variable(k, v)

backends.ScipyDataStore.set_variables(…[, …])

This provides a centralized method to set the variables on the data store.

backends.ScipyDataStore.store(variables, …)

Top level method for putting data on this store, this method:

backends.ScipyDataStore.store_dataset(dataset)

in stores, variables are all variables AND coordinates in xarray.Dataset variables are variables NOT coordinates, so here we pass the whole dataset in instead of doing dataset.variables

backends.ScipyDataStore.sync()

backends.ScipyDataStore.values()

backends.ScipyDataStore.attrs

backends.ScipyDataStore.dimensions

backends.ScipyDataStore.ds

backends.ScipyDataStore.variables

backends.FileManager.acquire([needs_lock])

Acquire the file object from this manager.

backends.FileManager.acquire_context([…])

Context manager for acquiring a file.

backends.FileManager.close([needs_lock])

Close the file object associated with this manager, if needed.

backends.CachingFileManager.acquire([needs_lock])

Acquire a file object from the manager.

backends.CachingFileManager.acquire_context([…])

Context manager for acquiring a file.

backends.CachingFileManager.close([needs_lock])

Explicitly close any associated file object (if necessary).

backends.DummyFileManager.acquire([needs_lock])

Acquire the file object from this manager.

backends.DummyFileManager.acquire_context([…])

Context manager for acquiring a file.

backends.DummyFileManager.close([needs_lock])

Close the file object associated with this manager, if needed.