SeriesHE¶

class SeriesHE(values: Union[Iterable[Any], numpy.ndarray, Mapping[Hashable, Any], int, float, str, bool], *, index: Optional[Union[static_frame.core.index_base.IndexBase, Iterable[Hashable], Iterable[Sequence[Hashable]], static_frame.core.index_auto.IndexAutoFactory, Type[static_frame.core.index_auto.IndexAutoFactory]]] = None, name: Optional[Hashable] = <object object>, dtype: Optional[Union[str, numpy.dtype, type]] = None, index_constructor: Optional[Callable[[...], static_frame.core.index_base.IndexBase]] = None, own_index: bool = False)[source]¶: A hash/equals subclass of Series, permiting usage in a Python set, dictionary, or other contexts where a hashable container is needed. To support hashability, __eq__ is implemented to return a Boolean rather than an Boolean Series.

SeriesHE: Constructor¶

SeriesHE.__init__(values: Union[Iterable[Any], numpy.ndarray, Mapping[Hashable, Any], int, float, str, bool], *, index: Optional[Union[static_frame.core.index_base.IndexBase, Iterable[Hashable], Iterable[Sequence[Hashable]], static_frame.core.index_auto.IndexAutoFactory, Type[static_frame.core.index_auto.IndexAutoFactory]]] = None, name: Optional[Hashable] = <object object>, dtype: Optional[Union[str, numpy.dtype, type]] = None, index_constructor: Optional[Callable[[...], static_frame.core.index_base.IndexBase]] = None, own_index: bool = False) → None

Initializer.

Parameters

values – An iterable of values to be aligned with the supplied (or automatically generated) index.
index – Optional index initializer. If provided in addition to data values, lengths must be compatible.
name –
dtype –
index_constructor –
own_index – Flag the passed index as ownable by this static_frame.Series. Primarily used by internal clients.

classmethod SeriesHE.from_concat(containers: Iterable[Union[Series, Bus]], *, index: Optional[Union[IndexBase, Iterable[Hashable], Iterable[Sequence[Hashable]], Type[static_frame.core.index_auto.IndexAutoFactory]]] = None, name: Optional[Hashable] = <object object>) → Series

Concatenate multiple Series into a new Series.

Parameters

containers – Iterable of Series from which values in the new Series are drawn.
index – If None, the resultant index will be the concatenation of all indices (assuming they are unique in combination). If IndexAutoFactory, the resultant index is a auto-incremented integer index. Otherwise, the value is used as a index initializer.

Returns

static_frame.Series

classmethod SeriesHE.from_concat_items(items: Iterable[Tuple[Hashable, static_frame.core.series.Series]], *, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], static_frame.core.index_base.IndexBase]] = None) → static_frame.core.series.Series

Produce a Series with a hierarchical index from an iterable of pairs of labels, Series. The IndexHierarchy is formed from the provided labels and the Index if each Series.

Parameters: items – Iterable of pairs of label, Series
Returns: static_frame.Series

classmethod SeriesHE.from_dict(mapping: Dict[Hashable, Any], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], static_frame.core.index_base.IndexBase]] = None) → static_frame.core.series.Series

Series construction from a dictionary, where the first pair value is the index and the second is the value.

Parameters

mapping – a dictionary or similar mapping interface.
dtype – dtype or valid dtype specifier.

Returns

Series

classmethod SeriesHE.from_element(element: Any, *, index: Union[static_frame.core.index_base.IndexBase, Iterable[Hashable], Iterable[Sequence[Hashable]], static_frame.core.index_auto.IndexAutoFactory], dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], static_frame.core.index_base.IndexBase]] = None, own_index: bool = False) → static_frame.core.series.Series

Create a static_frame.Series from a single element. The size of the resultant container will be determined by the index argument.

Returns: static_frame.Series

classmethod SeriesHE.from_items(pairs: Iterable[Tuple[Hashable, Any]], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], static_frame.core.index_base.IndexBase]] = None) → static_frame.core.series.Series

Series construction from an iterator or generator of pairs, where the first pair value is the index and the second is the value.

Parameters

pairs – Iterable of pairs of index, value.
dtype – dtype or valid dtype specifier.
name –
index_constructor –

Returns

static_frame.Series

classmethod SeriesHE.from_overlay(containers: Iterable[static_frame.core.series.Series], *, index: Optional[Union[static_frame.core.index_base.IndexBase, Iterable[Hashable], Iterable[Sequence[Hashable]]]] = None, union: bool = True, name: Optional[Hashable] = None) → static_frame.core.series.Series

Return a new Series made by overlaying containers, filling in missing values (None or NaN) with aligned values from subsequent containers.

Parameters

containers – Iterable of Series.
index – An Index or IndexHierarchy, or index initializer, to be used as the index upon which all containers are aligned. IndexAutoFactory is not supported.
union – If True, and no index argument is supplied, a union index from containers will be used; if False, the intersection index will be used.

classmethod SeriesHE.from_pandas(value: pandas.Series, *, index_constructor: Union[Callable[[...], IndexBase], None, Type[static_frame.core.index_auto.IndexAutoFactory]] = None, name: Optional[Hashable] = <object object>, own_data: bool = False) → Series

Given a Pandas Series, return a Series.

Parameters

value – Pandas Series.
own_data – If True, the underlying NumPy data array will be made immutable and used without a copy.
own_index – If True, the underlying NumPy index label array will be made immutable and used without a copy.

Returns

static_frame.Series

SeriesHE: Exporter¶

Overview: SeriesHE: Exporter

SeriesHE.to_frame(axis: int = 1) → Frame

Return a Frame view of this Series. As underlying data is immutable, this is a no-copy operation.

Returns: Frame

SeriesHE.to_frame_go(axis: int = 1) → FrameGO

Return FrameGO view of this Series. As underlying data is immutable, this is a no-copy operation.

Returns: FrameGO

SeriesHE.to_html(config: Optional[static_frame.core.display_config.DisplayConfig] = None, style_config: Optional[static_frame.core.style_config.StyleConfig] = <static_frame.core.style_config.StyleConfig object>) → str

Return an HTML table representation of this Series using standard TABLE, TR, and TD tags. This is not a complete HTML page.

Parameters: config – Optional DisplayConfig instance.
Returns: str

SeriesHE.to_html_datatables(fp: Optional[Union[str, os.PathLike, TextIO]] = None, show: bool = True, config: Optional[static_frame.core.display_config.DisplayConfig] = None) → Optional[str]

Return a complete HTML representation of this Series using the DataTables JS library for table naviagation and search. The page links to CDNs for JS resources, and thus will not fully render without an internet connection.

Parameters

fp – optional file path to write; if not provided, a temporary file will be created. Note: the caller is responsible for deleting this file.
show – if True, the file will be opened with a webbrowser.
config – Optional DisplayConfig instance.

Returns

str, absolute file path to the file written.

SeriesHE.to_pairs() → Iterable[Tuple[Hashable, Any]]

Return a tuple of tuples, where each inner tuple is a pair of index label, value.

Returns: tp.Iterable[tp.Tuple[tp.Hashable, tp.Any]]

SeriesHE.to_pandas() → pandas.Series

Return a Pandas Series.

Returns: pandas.Series

SeriesHE.to_series() → static_frame.core.series.Series[source]: Return a Series from this SeriesHE.

SeriesHE.to_series_he() → static_frame.core.series.SeriesHE: Return a SeriesHE from this Series.

SeriesHE.to_visidata() → None: Open an interactive VisiData session.

SeriesHE: Attribute¶

Overview: SeriesHE: Attribute

SeriesHE.STATIC: bool = True

SeriesHE.T

Transpose. For a 1D immutable container, this returns a reference to self.

Returns: Series

SeriesHE.dtype

Return the dtype of the underlying NumPy array.

Returns: numpy.dtype

SeriesHE.index

The index instance assigned to this container.

Returns: static_frame.Index

SeriesHE.mloc: The memory location, represented as an integer, of the underlying NumPy array.

SeriesHE.name

A hashable label attached to this container.

Returns: Hashable

SeriesHE.nbytes

Return the total bytes of the underlying NumPy array.

Returns: int

SeriesHE.ndim

Return the number of dimensions, which for a Series is always 1.

Returns: int

SeriesHE.shape

Return a tuple describing the shape of the underlying NumPy array.

Returns: Tuple[int]

SeriesHE.size

Return the size of the underlying NumPy array.

Returns: int

SeriesHE: Method¶

Overview: SeriesHE: Method

SeriesHE.__bool__() → bool: Raises ValueError to prohibit ambiguous use of truethy evaluation.

SeriesHE.__deepcopy__(memo: Dict[int, Any]) → static_frame.core.series.Series

SeriesHE.__len__() → int: Length of values.

SeriesHE.__round__(decimals: int = 0) → static_frame.core.series.Series

Return a Series rounded to the given decimals. Negative decimals round to the left of the decimal point.

Parameters: decimals – number of decimals to round to.
Returns: Series

SeriesHE.all(axis: int = 0, skipna: bool = True, out: Optional[numpy.ndarray] = None) → Any

Logical and over values along the specified axis.

Parameters

axis – Axis, defaulting to axis 0.
skipna – Skip missing (NaN) values, defaulting to True.

SeriesHE.any(axis: int = 0, skipna: bool = True, out: Optional[numpy.ndarray] = None) → Any

Logical or over values along the specified axis.

Parameters

axis – Axis, defaulting to axis 0.
skipna – Skip missing (NaN) values, defaulting to True.

SeriesHE.astype(dtype: Optional[Union[str, numpy.dtype, type]]) → static_frame.core.series.Series

Return a Series with type determined by dtype argument. Note that for Series, this is a simple function, whereas for Frame, this is an interface exposing both a callable and a getitem interface.

Parameters: dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.
Returns: Series

SeriesHE.clip(*, lower: Optional[Union[float, static_frame.core.series.Series]] = None, upper: Optional[Union[float, static_frame.core.series.Series]] = None) → static_frame.core.series.Series

Apply a clip operation to this Series. Note that clip operations can be applied to object types, but cannot be applied to non-numerical objects (e.g., strings, None)

Parameters

lower – value or Series to define the inclusive lower bound.
upper – value or Series to define the inclusive upper bound.

Returns

Series

SeriesHE.count(*, skipna: bool = True, skipfalsy: bool = False, unique: bool = False) → int

Return the count of non-NA, non-falsy, and/or unique elements.

Parameters

skipna – skip NA (NaN, None) values.
skipfalsy – skip falsu values (0, ‘’, False, None, NaN)
unique – Count unique items after optionally applying skipna or skipfalsy removals.

SeriesHE.cov(other: Union[static_frame.core.series.Series, numpy.ndarray], *, ddof: int = 1) → float

Return the index-aligned covariance to the supplied Series.

Parameters: ddof – Delta degrees of freedom, defaults to 1.

SeriesHE.cumprod(axis: int = 0, skipna: bool = True) → Any

Return the cumulative product over the specified axis.

Parameters

axis – Axis, defaulting to axis 0.
skipna – Skip missing (NaN) values, defaulting to True.

SeriesHE.cumsum(axis: int = 0, skipna: bool = True) → Any

Return the cumulative sum over the specified axis.

Parameters

axis – Axis, defaulting to axis 0.
skipna – Skip missing (NaN) values, defaulting to True.

SeriesHE.drop_duplicated(*, exclude_first: bool = False, exclude_last: bool = False) → static_frame.core.series.Series

Return a Series with duplicated values removed.

Parameters

exclude_first – Boolean to select if the first duplicated value is excluded.
exclude_last – Boolean to select if the last duplicated value is excluded.

Returns

Series

SeriesHE.dropfalsy() → static_frame.core.series.Series: Return a new Series after removing values of falsy.

SeriesHE.dropna() → static_frame.core.series.Series: Return a new Series after removing values of NaN or None.

SeriesHE.duplicated(*, exclude_first: bool = False, exclude_last: bool = False) → numpy.ndarray

Return a same-sized Boolean Series that shows True for all values that are duplicated.

Parameters

exclude_first – Boolean to select if the first duplicated value is excluded.
exclude_last – Boolean to select if the last duplicated value is excluded.

Returns

numpy.ndarray

SeriesHE.equals(other: Any, *, compare_name: bool = False, compare_dtype: bool = False, compare_class: bool = False, skipna: bool = True) → bool

Return a bool from comparison to any other object.

Parameters

compare_name – Include equality of the container’s name (and all composed containers) in the comparison.
compare_dtype – Include equality of the container’s dtype (and all composed containers) in the comparison.
compare_class – Include equality of the container’s class (and all composed containers) in the comparison.
skipna – If True, comparisons between missing values are equal.

SeriesHE.fillfalsy(value: Any) → static_frame.core.series.Series

Return a new Series after replacing falsy values with the supplied value. The value can be an element or Series.

Parameters: value – Value to be used to replace missing values (NaN or None).

SeriesHE.fillfalsy_backward(limit: int = 0) → static_frame.core.series.Series

Return a new Series after feeding backward the last non-falsy observation across contiguous falsy values.

Parameters: limit – Set the maximum count of missing values (NaN or None) to be filled per contiguous region of missing vlaues. A value of 0 is equivalent to no limit.

SeriesHE.fillfalsy_forward(limit: int = 0) → static_frame.core.series.Series

Return a new Series after feeding forward the last non-falsy observation across contiguous falsy values.

Parameters: limit – Set the maximum count of missing values (NaN or None) to be filled per contiguous region of missing vlaues. A value of 0 is equivalent to no limit.

SeriesHE.fillfalsy_leading(value: Any) → static_frame.core.series.Series

Return a new Series after filling leading (and only leading) falsy values with the supplied value.

Parameters: value – Value to be used to replace missing values (NaN or None).

SeriesHE.fillfalsy_trailing(value: Any) → static_frame.core.series.Series

Return a new Series after filling trailing (and only trailing) falsy values with the supplied value.

Parameters: value – Value to be used to replace missing values (NaN or None).

SeriesHE.fillna(value: Any) → static_frame.core.series.Series

Return a new Series after replacing NA (NaN or None) with the supplied value. The value can be an element or Series.

Parameters: value – Value to be used to replace missing values (NaN or None).

SeriesHE.fillna_backward(limit: int = 0) → static_frame.core.series.Series

Return a new Series after feeding backward the last non-null (NaN or None) observation across contiguous nulls.

Parameters: limit – Set the maximum count of missing values (NaN or None) to be filled per contiguous region of missing vlaues. A value of 0 is equivalent to no limit.

SeriesHE.fillna_forward(limit: int = 0) → static_frame.core.series.Series

Return a new Series after feeding forward the last non-null (NaN or None) observation across contiguous nulls.

Parameters: limit – Set the maximum count of missing values (NaN or None) to be filled per contiguous region of missing vlaues. A value of 0 is equivalent to no limit.

SeriesHE.fillna_leading(value: Any) → static_frame.core.series.Series

Return a new Series after filling leading (and only leading) null (NaN or None) with the supplied value.

Parameters: value – Value to be used to replace missing values (NaN or None).

SeriesHE.fillna_trailing(value: Any) → static_frame.core.series.Series

Return a new Series after filling trailing (and only trailing) null (NaN or None) with the supplied value.

Parameters: value – Value to be used to replace missing values (NaN or None).

SeriesHE.head(count: int = 5) → static_frame.core.series.Series

Return a Series consisting only of the top elements as specified by count.

Parameters: count – Number of elements to be returned from the top of the Series
Returns: Series

SeriesHE.iloc_max(*, skipna: bool = True) → int

Return the integer index corresponding to the maximum value.

Parameters: skipna – if True, NaN or None values will be ignored; if False, a found NaN will propagate.
Returns: int

SeriesHE.iloc_min(*, skipna: bool = True) → int

Return the integer index corresponding to the minimum value found.

Parameters: skipna – if True, NaN or None values will be ignored; if False, a found NaN will propagate.
Returns: int

SeriesHE.iloc_searchsorted(values: Any, *, side_left: bool = True) → Union[Hashable, Iterable[Hashable]]

Given a sorted Series, return the iloc (integer) position(s) at which insertion in values would retain sort order.

Parameters

values – a single value, or iterable of values.
side_left – If True, the index of the first suitable location found is given, else return the last such index. If matching an existing value, side_left==True will return that position, side_left==Right will return the next position (or the length).

SeriesHE.insert_after(key: Hashable, container: static_frame.core.series.Series) → static_frame.core.series.Series

Create a new Series by inserting a Series at the position after the label specified by key.

Parameters

key – Label after which the new container will be inserted.
container – Container to be inserted.

Returns

Series

SeriesHE.insert_before(key: Hashable, container: static_frame.core.series.Series) → static_frame.core.series.Series

Create a new Series by inserting a Series at the position before the label specified by key.

Parameters

key – Label before which the new container will be inserted.
container – Container to be inserted.

Returns

Series

SeriesHE.isfalsy() → static_frame.core.series.Series: Return a same-indexed, Boolean Series indicating which values are falsy.

SeriesHE.isin(other: Iterable[Any]) → static_frame.core.series.Series

Return a same-sized Boolean Series that shows if the same-positioned element is in the iterable passed to the function.

Returns: Series

SeriesHE.isna() → static_frame.core.series.Series: Return a same-indexed, Boolean Series indicating which values are NaN or None.

SeriesHE.loc_max(*, skipna: bool = True) → Hashable

Return the label corresponding to the maximum value found.

Parameters: skipna – if True, NaN or None values will be ignored; if False, a found NaN will propagate.
Returns: tp.Hashable

SeriesHE.loc_min(*, skipna: bool = True) → Hashable

Return the label corresponding to the minimum value found.

Parameters: skipna – if True, NaN or None values will be ignored; if False, a found NaN will propagate.
Returns: tp.Hashable

SeriesHE.loc_searchsorted(values: Any, *, side_left: bool = True, fill_value: Any = nan) → Union[Hashable, Iterable[Hashable]]

Given a sorted Series, return the loc (label) position(s) at which insertion in values would retain sort order.

Parameters

values – a single value, or iterable of values.
side_left – If True, the index of the first suitable location found is given, else return the last such index. If matching an existing value, side_left==True will return that position, side_left==Right will return the next position (or the length).
fill_value – A value to be used to fill the label beyond the last label.

SeriesHE.max(axis: int = 0, skipna: bool = True) → Any

Return the maximum along the specified axis.

Parameters

axis – Axis, defaulting to axis 0.
skipna – Skip missing (NaN) values, defaulting to True.

SeriesHE.mean(axis: int = 0, skipna: bool = True, out: Optional[numpy.ndarray] = None) → Any

Return the mean along the specified axis.

Parameters

axis – Axis, defaulting to axis 0.
skipna – Skip missing (NaN) values, defaulting to True.

SeriesHE.median(axis: int = 0, skipna: bool = True, out: Optional[numpy.ndarray] = None) → Any

Return the median along the specified axis.

Parameters

axis – Axis, defaulting to axis 0.
skipna – Skip missing (NaN) values, defaulting to True.

SeriesHE.min(axis: int = 0, skipna: bool = True, out: Optional[numpy.ndarray] = None) → Any

Return the minimum along the specified axis.

Parameters

axis – Axis, defaulting to axis 0.
skipna – Skip missing (NaN) values, defaulting to True.

SeriesHE.notfalsy() → static_frame.core.series.Series: Return a same-indexed, Boolean Series indicating which values are falsy.

SeriesHE.notna() → static_frame.core.series.Series: Return a same-indexed, Boolean Series indicating which values are NaN or None.

SeriesHE.prod(axis: int = 0, skipna: bool = True, out: Optional[numpy.ndarray] = None) → Any

Return the product along the specified axis.

Parameters

axis – Axis, defaulting to axis 0.
skipna – Skip missing (NaN) values, defaulting to True.

SeriesHE.rank_dense(*, skipna: bool = True, ascending: bool = True, start: int = 0, fill_value: Any = nan) → static_frame.core.series.Series

Rank values as compactly as possible, where ties get the same value, and ranks are contiguous (potentially non-unique) integers.

Parameters

skipna – If True, exclude NA values (NaN or None) from ranking, replacing those values with fill_value.
ascending – If True, the lowest ranks correspond to the lowest values. The default is True.
start – The reference value for the lowest rank. Some ranking methodologies (mean, max) may not return this value given some inputs. The default is 0; for ranks that start from 1, provide a value of 1.
fill_value – A value to be used to fill NA values ignored in ranking when skipna is True. The default is np.nan but can be set to any value to force NA values to the “bottom” or “top” of a rank as needed.

Returns

Series

SeriesHE.rank_max(*, skipna: bool = True, ascending: bool = True, start: int = 0, fill_value: Any = nan) → static_frame.core.series.Series

Rank values where tied values are assigned the maximum ordinal rank; ranks are potentially non-contiguous and non-unique integers.

Parameters

skipna – If True, exclude NA values (NaN or None) from ranking, replacing those values with fill_value.
ascending – If True, the lowest ranks correspond to the lowest values. The default is True.
start – The reference value for the lowest rank. Some ranking methodologies (mean, max) may not return this value given some inputs. The default is 0; for ranks that start from 1, provide a value of 1.
fill_value – A value to be used to fill NA values ignored in ranking when skipna is True. The default is np.nan but can be set to any value to force NA values to the “bottom” or “top” of a rank as needed.

Returns

Series

SeriesHE.rank_mean(*, skipna: bool = True, ascending: bool = True, start: int = 0, fill_value: Any = nan) → static_frame.core.series.Series

Rank values where tied values are assigned the mean of the ordinal ranks; ranks are potentially non-contiguous and non-unique floats.

Parameters

skipna – If True, exclude NA values (NaN or None) from ranking, replacing those values with fill_value.
ascending – If True, the lowest ranks correspond to the lowest values. The default is True.
start – The reference value for the lowest rank. Some ranking methodologies (mean, max) may not return this value given some inputs. The default is 0; for ranks that start from 1, provide a value of 1.
fill_value – A value to be used to fill NA values ignored in ranking when skipna is True. The default is np.nan but can be set to any value to force NA values to the “bottom” or “top” of a rank as needed.

Returns

Series

SeriesHE.rank_min(*, skipna: bool = True, ascending: bool = True, start: int = 0, fill_value: Any = nan) → static_frame.core.series.Series

Rank values where tied values are assigned the minimum ordinal rank; ranks are potentially non-contiguous and non-unique integers.

Parameters

skipna – If True, exclude NA values (NaN or None) from ranking, replacing those values with fill_value.
ascending – If True, the lowest ranks correspond to the lowest values. The default is True.
start – The reference value for the lowest rank. Some ranking methodologies (mean, max) may not return this value given some inputs. The default is 0; for ranks that start from 1, provide a value of 1.
fill_value – A value to be used to fill NA values ignored in ranking when skipna is True. The default is np.nan but can be set to any value to force NA values to the “bottom” or “top” of a rank as needed.

Returns

Series

SeriesHE.rank_ordinal(*, skipna: bool = True, ascending: bool = True, start: int = 0, fill_value: Any = nan) → static_frame.core.series.Series

Rank values distinctly, where ties get distinct values that maintain their ordering, and ranks are contiguous unique integers.

Parameters

skipna – If True, exclude NA values (NaN or None) from ranking, replacing those values with fill_value.
ascending – If True, the lowest ranks correspond to the lowest values. The default is True.
start – The reference value for the lowest rank. Some ranking methodologies (mean, max) may not return this value given some inputs. The default is 0; for ranks that start from 1, provide a value of 1.
fill_value – A value to be used to fill NA values ignored in ranking when skipna is True. The default is np.nan but can be set to any value to force NA values to the “bottom” or “top” of a rank as needed.

Returns

Series

SeriesHE.rehierarch(depth_map: Sequence[int]) → static_frame.core.series.Series: Return a new Series with new a hierarchy based on the supplied depth_map.

SeriesHE.reindex(index: Union[static_frame.core.index_base.IndexBase, Iterable[Hashable], Iterable[Sequence[Hashable]]], *, fill_value: Any = nan, own_index: bool = False, check_equals: bool = True) → static_frame.core.series.Series

Return a new Series with labels defined by the provided index. The size and ordering of the data is determined by the newly provided index, where data will continue to be aligned under labels found in both the new and the old index. Labels found only in the new index will be filled with fill_value.

Parameters

index – An iterable of unique, hashable values, or another Index or IndexHierarchy, to be used as the labels of the index.
columns – An iterable of unique, hashable values, or another Index or IndexHierarchy, to be used as the labels of the index.
fill_value – A value to be used to fill space created by a new index that has values not found in the previous index.
own_index – Flag the passed index as ownable by this static_frame.Series. Primarily used by internal clients.

SeriesHE.relabel(index: Optional[Union[Callable[[...], Any], Mapping[Hashable, Any], static_frame.core.series.Series, Type[static_frame.core.index_auto.IndexAutoFactory], static_frame.core.index_base.IndexBase, Iterable[Hashable], Iterable[Sequence[Hashable]]]]) → static_frame.core.series.Series

Return a new Series with transformed labels on the index. The size and ordering of the data is never changed in a relabeling operation. The resulting index must be unique.

Parameters: index – One of the following types, used to create a new Index with the same size as the previous index. (a) A mapping (as a dictionary or Series), used to lookup and transform the labels in the previous index. Previous labels not found in the mapping will be reused. (b) A function, returning a hashable, that is applied to each label in the previous index. (c) The IndexAutoFactory type, to apply an auto-incremented integer index. (d) An index initializer, i.e., either an iterable of hashables or an Index instance.

SeriesHE.relabel_flat() → static_frame.core.series.Series: Return a new Series, where an IndexHierarchy (if defined) is replaced with a flat, one-dimension index of tuples.

SeriesHE.relabel_level_add(level: Hashable) → static_frame.core.series.Series

Return a new Series, adding a new root level to an existing IndexHierarchy, or creating an IndexHierarchy if one is not yet defined.

Parameters: level – A hashable value to be used as a new root level, extending or creating an IndexHierarchy

SeriesHE.relabel_level_drop(count: int = 1) → static_frame.core.series.Series

Return a new Series, dropping one or more levels from a either the root or the leaves of an IndexHierarchy. The resulting index must be unique.

Parameters: count – A positive integer drops that many outer-most (root) levels; a negative integer drops that many inner-most (leaf)levels.

SeriesHE.rename(name: Optional[Hashable] = <object object>, *, index: Optional[Hashable] = <object object>) → static_frame.core.series.Series: Return a new Series with an updated name attribute.

SeriesHE.roll(shift: int, *, include_index: bool = False) → static_frame.core.series.Series

Return a Series with values rotated forward and wrapped around the index (with a positive shift) or backward and wrapped around the index (with a negative shift).

Parameters

shift – Positive or negative integer shift.
include_index – Determine if the Index is shifted with the underlying data.

Returns

Series

SeriesHE.sample(count: int = 1, *, seed: Optional[int] = None) → static_frame.core.series.Series

Randomly (optionally made deterministic with a fixed seed) extract items from the container to return a subset of the container.

Parameters

select. (Number of elements to) –
selection. (Initial state of random) –

SeriesHE.shift(shift: int, *, fill_value: Any = nan) → static_frame.core.series.Series

Return a Series with values shifted forward on the index (with a positive shift) or backward on the index (with a negative shift).

Parameters

shift – Positive or negative integer shift.
fill_value – Value to be used to fill data missing after the shift.

Returns

Series

SeriesHE.sort_index(*, ascending: Union[bool, Iterable[bool]] = True, kind: str = 'mergesort', key: Optional[Callable[[static_frame.core.index_base.IndexBase], Union[numpy.ndarray, static_frame.core.index_base.IndexBase]]] = None) → static_frame.core.series.Series

Return a new Series ordered by the sorted Index.

Parameters

* –
ascending – Boolean, or iterable of Booleans; if True, the lowest ranks correspond to the lowest values; if an iterable, apply per column or row. The default is True.
kind – Name of the sort algorithm as passed to NumPy.
key – A function that is used to pre-process the selected columns or rows and derive new values to sort by.

Returns

Series

SeriesHE.sort_values(*, ascending: bool = True, kind: str = 'mergesort', key: Optional[Callable[[static_frame.core.series.Series], Union[numpy.ndarray, static_frame.core.series.Series]]] = None) → static_frame.core.series.Series

Return a new Series ordered by the sorted values.

Parameters

* –
ascending – If True, sort in ascending order; if False, sort in descending order.
kind – Name of the sort algorithm as passed to NumPy.
key – A function that is used to pre-process the selected columns or rows and derive new values to sort by.

Returns

Series

SeriesHE.std(axis: int = 0, skipna: bool = True, ddof: int = 0, out: Optional[numpy.ndarray] = None) → Any

Return the standard deviaton along the specified axis.

Parameters

axis – Axis, defaulting to axis 0.
skipna – Skip missing (NaN) values, defaulting to True.

SeriesHE.sum(axis: int = 0, skipna: bool = True, out: Optional[numpy.ndarray] = None) → Any

Sum values along the specified axis.

Parameters

axis – Axis, defaulting to axis 0.
skipna – Skip missing (NaN) values, defaulting to True.

SeriesHE.tail(count: int = 5) → static_frame.core.series.Series

Return a Series consisting only of the bottom elements as specified by count.: s

Parameters: count – Number of elements to be returned from the bottom of the Series
Returns: Series

SeriesHE.transpose() → static_frame.core.series.Series

Transpose. For a 1D immutable container, this returns a reference to self.

Returns: Series

SeriesHE.unique() → numpy.ndarray

Return a NumPy array of unique values.

Returns: numpy.ndarray

SeriesHE.var(axis: int = 0, skipna: bool = True, ddof: int = 0, out: Optional[numpy.ndarray] = None) → Any

Return the variance along the specified axis.

Parameters

axis – Axis, defaulting to axis 0.
skipna – Skip missing (NaN) values, defaulting to True.

SeriesHE: Dictionary-Like¶

Overview: SeriesHE: Dictionary-Like

SeriesHE.__contains__(value: Hashable) → bool

Inclusion of value in index labels.

Returns: bool

SeriesHE.__iter__() → Iterator[Hashable]

Iterator of index labels, same as static_frame.Series.keys.

Returns: Iterator[Hashasble]

SeriesHE.__reversed__() → Iterator[Hashable]

Returns a reverse iterator on the series’ index.

Returns: Index

SeriesHE.get(key: Hashable, default: Optional[Any] = None) → Any

Return the value found at the index key, else the default if the key is not found.

Returns: Any

SeriesHE.items() → Iterator[Tuple[Any, Any]]

Iterator of pairs of index label and value.

Returns: Iterator[Tuple[Hashable, Any]]

SeriesHE.keys() → static_frame.core.index_base.IndexBase

Iterator of index labels.

Returns: Iterator[Hashable]

SeriesHE.values: np.ndarray

SeriesHE: Display¶

Overview: SeriesHE: Display

SeriesHE.interface¶: A Frame documenting the interface of this class.

SeriesHE.__repr__() → str: Return repr(self).

SeriesHE.__str__(): Return str(self).

SeriesHE.display(config: Optional[static_frame.core.display_config.DisplayConfig] = None, *, style_config: Optional[static_frame.core.style_config.StyleConfig] = None) → static_frame.core.display.Display

Return a static_frame.Display, capable of providing a string representation.

Parameters: config – A static_frame.DisplayConfig instance. If not provided, the static_frame.DisplayActive will be used.

SeriesHE.display_tall(config: Optional[static_frame.core.display_config.DisplayConfig] = None) → static_frame.core.display.Display

Maximize vertical presentation. Return a static_frame.Display, capable of providing a string representation.

Parameters: config – A static_frame.DisplayConfig instance. If not provided, the static_frame.DisplayActive will be used.

SeriesHE.display_wide(config: Optional[static_frame.core.display_config.DisplayConfig] = None) → static_frame.core.display.Display

Maximize horizontal presentation. Return a static_frame.Display, capable of providing a string representation.

Parameters: config – A static_frame.DisplayConfig instance. If not provided, the static_frame.DisplayActive will be used.

SeriesHE: Assignment¶

Overview: SeriesHE: Assignment

SeriesHE.assign[key](value, *, fill_value)

SeriesHE.assign: Interface for doing assignment-like selection and replacement.

SeriesAssign.__call__(value: Any, *, fill_value: Any = nan) → static_frame.core.series.Series[source]

Assign the value in the position specified by the selector. The name attribute is propagated to the returned container.

Parameters

value – Value to assign, which can be a Series, np.ndarray, or element.
*. –
fill_value – If the value parameter has to be reindexed, this element will be used to fill newly created elements.

SeriesHE.assign[key].apply(func, *, fill_value)

SeriesHE.assign: Interface for doing assignment-like selection and replacement.

SeriesAssign.apply(func: Callable[[...], Any], *, fill_value: Any = nan) → static_frame.core.series.Series[source]

Provide a function to apply to the assignment target, and use that as the assignment value.

Parameters

func – A function to apply to the assignment target.
*. –
fill_value – If the function does not produce a container with a matching index, the element will be used to fill newly created elements.

SeriesHE.assign.iloc[key](value, *, fill_value)

SeriesHE.assign: Interface for doing assignment-like selection and replacement.

SeriesAssign.__call__(value: Any, *, fill_value: Any = nan) → static_frame.core.series.Series[source]

Assign the value in the position specified by the selector. The name attribute is propagated to the returned container.

Parameters

value – Value to assign, which can be a Series, np.ndarray, or element.
*. –
fill_value – If the value parameter has to be reindexed, this element will be used to fill newly created elements.

SeriesHE.assign.iloc[key].apply(func, *, fill_value)

SeriesHE.assign: Interface for doing assignment-like selection and replacement.

SeriesAssign.apply(func: Callable[[...], Any], *, fill_value: Any = nan) → static_frame.core.series.Series[source]

Provide a function to apply to the assignment target, and use that as the assignment value.

Parameters

func – A function to apply to the assignment target.
*. –
fill_value – If the function does not produce a container with a matching index, the element will be used to fill newly created elements.

SeriesHE.assign.loc[key](value, *, fill_value)

SeriesHE.assign: Interface for doing assignment-like selection and replacement.

SeriesAssign.__call__(value: Any, *, fill_value: Any = nan) → static_frame.core.series.Series[source]

Assign the value in the position specified by the selector. The name attribute is propagated to the returned container.

Parameters

value – Value to assign, which can be a Series, np.ndarray, or element.
*. –
fill_value – If the value parameter has to be reindexed, this element will be used to fill newly created elements.

SeriesHE.assign.loc[key].apply(func, *, fill_value)

SeriesHE.assign: Interface for doing assignment-like selection and replacement.

SeriesAssign.apply(func: Callable[[...], Any], *, fill_value: Any = nan) → static_frame.core.series.Series[source]

Provide a function to apply to the assignment target, and use that as the assignment value.

Parameters

func – A function to apply to the assignment target.
*. –
fill_value – If the function does not produce a container with a matching index, the element will be used to fill newly created elements.

SeriesHE: Selector¶

Overview: SeriesHE: Selector

SeriesHE.drop[key]

SeriesHE.drop: Interface for dropping elements from static_frame.Series.

InterfaceSelectTrio.__getitem__(key: Union[int, numpy.integer, slice, List[Any], None, Index, Series, numpy.ndarray]) → Any[source]: Label-based selection.

SeriesHE.drop.iloc[key]

SeriesHE.drop: Interface for dropping elements from static_frame.Series.

InterfaceSelectTrio.iloc: Integer-position based selection.

SeriesHE.drop.loc[key]

SeriesHE.drop: Interface for dropping elements from static_frame.Series.

InterfaceSelectTrio.loc: Label-based selection.

SeriesHE.mask[key]

SeriesHE.mask: Interface for extracting Boolean static_frame.Series.

InterfaceSelectTrio.__getitem__(key: Union[int, numpy.integer, slice, List[Any], None, Index, Series, numpy.ndarray]) → Any[source]: Label-based selection.

SeriesHE.mask.iloc[key]

SeriesHE.mask: Interface for extracting Boolean static_frame.Series.

InterfaceSelectTrio.iloc: Integer-position based selection.

SeriesHE.mask.loc[key]

SeriesHE.mask: Interface for extracting Boolean static_frame.Series.

InterfaceSelectTrio.loc: Label-based selection.

SeriesHE.masked_array[key]

SeriesHE.masked_array: Interface for extracting NumPy Masked Arrays.

InterfaceSelectTrio.__getitem__(key: Union[int, numpy.integer, slice, List[Any], None, Index, Series, numpy.ndarray]) → Any[source]: Label-based selection.

SeriesHE.masked_array.iloc[key]

SeriesHE.masked_array: Interface for extracting NumPy Masked Arrays.

InterfaceSelectTrio.iloc: Integer-position based selection.

SeriesHE.masked_array.loc[key]

SeriesHE.masked_array: Interface for extracting NumPy Masked Arrays.

InterfaceSelectTrio.loc: Label-based selection.

SeriesHE[key]

SeriesHE.__getitem__ = <function Series.__getitem__>

SeriesHE.iloc[key]

SeriesHE.iloc: Interface for position-based selection.

SeriesHE.loc[key]

SeriesHE.loc: Interface for label-based selection.

SeriesHE: Iterator¶

Overview: SeriesHE: Iterator

SeriesHE.iter_element

iter_element: Iterator of elements.

SeriesHE.iter_element().apply(func, *, dtype, name, index_constructor)

iter_element: Iterator of elements.

IterNodeDelegate.apply(func: Callable[[...], Any], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a function to each value. Returns a new container.

Parameters

func – A function that takes a value.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_element().apply_iter(func)

iter_element: Iterator of elements.

IterNodeDelegate.apply_iter(func: Callable[[...], Any]) → Iterator[Any][source]

Apply a function to each value. A generator of resulting values.

Parameters: func – A function that takes a value.

SeriesHE.iter_element().apply_iter_items(func)

iter_element: Iterator of elements.

IterNodeDelegate.apply_iter_items(func: Callable[[...], Any]) → Iterator[Tuple[Any, Any]][source]

Apply a function to each value. A generator of resulting key, value pairs.

Parameters: func – A function that takes a value.

SeriesHE.iter_element().apply_pool(func, *, dtype, name, index_constructor, max_workers, chunksize, use_threads)

iter_element: Iterator of elements.

IterNodeDelegate.apply_pool(func: Callable[[...], Any], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None, max_workers: Optional[int] = None, chunksize: int = 1, use_threads: bool = False) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a function to each value. Employ parallel processing with either the ProcessPoolExecutor or ThreadPoolExecutor.

Parameters

func – A function that takes a value.
* –
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.
name – A hashable object to label the container.
max_workers – Number of parallel executors, as passed to the Thread- or ProcessPoolExecutor; None defaults to the max number of machine processes.
chunksize – Units of work per executor, as passed to the Thread- or ProcessPoolExecutor.
use_threads – Use the ThreadPoolExecutor instead of the ProcessPoolExecutor.

SeriesHE.iter_element().map_all(mapping, *, dtype, name, index_constructor)

iter_element: Iterator of elements.

IterNodeDelegate.map_all(mapping: Union[Mapping[Hashable, Any], Series], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, an Exception is raised. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_element().map_all_iter(mapping)

iter_element: Iterator of elements.

IterNodeDelegate.map_all_iter(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, an Exception is raised. A generator of resulting values.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_element().map_all_iter_items(mapping)

iter_element: Iterator of elements.

IterNodeDelegate.map_all_iter_items(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, an Exception is raised. A generator of resulting key, value pairs.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_element().map_any(mapping, *, dtype, name, index_constructor)

iter_element: Iterator of elements.

IterNodeDelegate.map_any(mapping: Union[Mapping[Hashable, Any], Series], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, the value is returned. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_element().map_any_iter(mapping)

iter_element: Iterator of elements.

IterNodeDelegate.map_any_iter(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, the value is returned. A generator of resulting values.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_element().map_any_iter_items(mapping)

iter_element: Iterator of elements.

IterNodeDelegate.map_any_iter_items(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, the value is returned. A generator of resulting key, value pairs.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_element().map_fill(mapping, *, fill_value, dtype, name, index_constructor)

iter_element: Iterator of elements.

IterNodeDelegate.map_fill(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, the fill_value is returned. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_element().map_fill_iter(mapping, *, fill_value)

iter_element: Iterator of elements.

IterNodeDelegate.map_fill_iter(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, the fill_value is returned. A generator of resulting values.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.

SeriesHE.iter_element().map_fill_iter_items(mapping, *, fill_value)

iter_element: Iterator of elements.

IterNodeDelegate.map_fill_iter_items(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, the fill_value is returned. A generator of resulting key, value pairs.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.

SeriesHE.iter_element_items

iter_element_items: Iterator of label, element pairs.

SeriesHE.iter_element_items().apply(func, *, dtype, name, index_constructor)

iter_element_items: Iterator of label, element pairs.

IterNodeDelegate.apply(func: Callable[[...], Any], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a function to each value. Returns a new container.

Parameters

func – A function that takes a value.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_element_items().apply_iter(func)

iter_element_items: Iterator of label, element pairs.

IterNodeDelegate.apply_iter(func: Callable[[...], Any]) → Iterator[Any][source]

Apply a function to each value. A generator of resulting values.

Parameters: func – A function that takes a value.

SeriesHE.iter_element_items().apply_iter_items(func)

iter_element_items: Iterator of label, element pairs.

IterNodeDelegate.apply_iter_items(func: Callable[[...], Any]) → Iterator[Tuple[Any, Any]][source]

Apply a function to each value. A generator of resulting key, value pairs.

Parameters: func – A function that takes a value.

SeriesHE.iter_element_items().apply_pool(func, *, dtype, name, index_constructor, max_workers, chunksize, use_threads)

iter_element_items: Iterator of label, element pairs.

IterNodeDelegate.apply_pool(func: Callable[[...], Any], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None, max_workers: Optional[int] = None, chunksize: int = 1, use_threads: bool = False) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a function to each value. Employ parallel processing with either the ProcessPoolExecutor or ThreadPoolExecutor.

Parameters

func – A function that takes a value.
* –
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.
name – A hashable object to label the container.
max_workers – Number of parallel executors, as passed to the Thread- or ProcessPoolExecutor; None defaults to the max number of machine processes.
chunksize – Units of work per executor, as passed to the Thread- or ProcessPoolExecutor.
use_threads – Use the ThreadPoolExecutor instead of the ProcessPoolExecutor.

SeriesHE.iter_element_items().map_all(mapping, *, dtype, name, index_constructor)

iter_element_items: Iterator of label, element pairs.

IterNodeDelegate.map_all(mapping: Union[Mapping[Hashable, Any], Series], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, an Exception is raised. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_element_items().map_all_iter(mapping)

iter_element_items: Iterator of label, element pairs.

IterNodeDelegate.map_all_iter(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, an Exception is raised. A generator of resulting values.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_element_items().map_all_iter_items(mapping)

iter_element_items: Iterator of label, element pairs.

IterNodeDelegate.map_all_iter_items(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, an Exception is raised. A generator of resulting key, value pairs.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_element_items().map_any(mapping, *, dtype, name, index_constructor)

iter_element_items: Iterator of label, element pairs.

IterNodeDelegate.map_any(mapping: Union[Mapping[Hashable, Any], Series], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, the value is returned. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_element_items().map_any_iter(mapping)

iter_element_items: Iterator of label, element pairs.

IterNodeDelegate.map_any_iter(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, the value is returned. A generator of resulting values.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_element_items().map_any_iter_items(mapping)

iter_element_items: Iterator of label, element pairs.

IterNodeDelegate.map_any_iter_items(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, the value is returned. A generator of resulting key, value pairs.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_element_items().map_fill(mapping, *, fill_value, dtype, name, index_constructor)

iter_element_items: Iterator of label, element pairs.

IterNodeDelegate.map_fill(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, the fill_value is returned. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_element_items().map_fill_iter(mapping, *, fill_value)

iter_element_items: Iterator of label, element pairs.

IterNodeDelegate.map_fill_iter(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, the fill_value is returned. A generator of resulting values.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.

SeriesHE.iter_element_items().map_fill_iter_items(mapping, *, fill_value)

iter_element_items: Iterator of label, element pairs.

IterNodeDelegate.map_fill_iter_items(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, the fill_value is returned. A generator of resulting key, value pairs.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.

SeriesHE.iter_group(*, axis)

iter_group: Iterator of Series, where each Series matches unique values.

SeriesHE.iter_group(*, axis).apply(func, *, dtype, name, index_constructor)

iter_group: Iterator of Series, where each Series matches unique values.

IterNodeDelegate.apply(func: Callable[[...], Any], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a function to each value. Returns a new container.

Parameters

func – A function that takes a value.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_group(*, axis).apply_iter(func)

iter_group: Iterator of Series, where each Series matches unique values.

IterNodeDelegate.apply_iter(func: Callable[[...], Any]) → Iterator[Any][source]

Apply a function to each value. A generator of resulting values.

Parameters: func – A function that takes a value.

SeriesHE.iter_group(*, axis).apply_iter_items(func)

iter_group: Iterator of Series, where each Series matches unique values.

IterNodeDelegate.apply_iter_items(func: Callable[[...], Any]) → Iterator[Tuple[Any, Any]][source]

Apply a function to each value. A generator of resulting key, value pairs.

Parameters: func – A function that takes a value.

SeriesHE.iter_group(*, axis).apply_pool(func, *, dtype, name, index_constructor, max_workers, chunksize, use_threads)

iter_group: Iterator of Series, where each Series matches unique values.

IterNodeDelegate.apply_pool(func: Callable[[...], Any], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None, max_workers: Optional[int] = None, chunksize: int = 1, use_threads: bool = False) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a function to each value. Employ parallel processing with either the ProcessPoolExecutor or ThreadPoolExecutor.

Parameters

func – A function that takes a value.
* –
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.
name – A hashable object to label the container.
max_workers – Number of parallel executors, as passed to the Thread- or ProcessPoolExecutor; None defaults to the max number of machine processes.
chunksize – Units of work per executor, as passed to the Thread- or ProcessPoolExecutor.
use_threads – Use the ThreadPoolExecutor instead of the ProcessPoolExecutor.

SeriesHE.iter_group(*, axis).map_all(mapping, *, dtype, name, index_constructor)

iter_group: Iterator of Series, where each Series matches unique values.

IterNodeDelegate.map_all(mapping: Union[Mapping[Hashable, Any], Series], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, an Exception is raised. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_group(*, axis).map_all_iter(mapping)

iter_group: Iterator of Series, where each Series matches unique values.

IterNodeDelegate.map_all_iter(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, an Exception is raised. A generator of resulting values.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_group(*, axis).map_all_iter_items(mapping)

iter_group: Iterator of Series, where each Series matches unique values.

IterNodeDelegate.map_all_iter_items(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, an Exception is raised. A generator of resulting key, value pairs.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_group(*, axis).map_any(mapping, *, dtype, name, index_constructor)

iter_group: Iterator of Series, where each Series matches unique values.

IterNodeDelegate.map_any(mapping: Union[Mapping[Hashable, Any], Series], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, the value is returned. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_group(*, axis).map_any_iter(mapping)

iter_group: Iterator of Series, where each Series matches unique values.

IterNodeDelegate.map_any_iter(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, the value is returned. A generator of resulting values.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_group(*, axis).map_any_iter_items(mapping)

iter_group: Iterator of Series, where each Series matches unique values.

IterNodeDelegate.map_any_iter_items(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, the value is returned. A generator of resulting key, value pairs.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_group(*, axis).map_fill(mapping, *, fill_value, dtype, name, index_constructor)

iter_group: Iterator of Series, where each Series matches unique values.

IterNodeDelegate.map_fill(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, the fill_value is returned. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_group(*, axis).map_fill_iter(mapping, *, fill_value)

iter_group: Iterator of Series, where each Series matches unique values.

IterNodeDelegate.map_fill_iter(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, the fill_value is returned. A generator of resulting values.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.

SeriesHE.iter_group(*, axis).map_fill_iter_items(mapping, *, fill_value)

iter_group: Iterator of Series, where each Series matches unique values.

IterNodeDelegate.map_fill_iter_items(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, the fill_value is returned. A generator of resulting key, value pairs.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.

SeriesHE.iter_group_items(*, axis)

iter_group_items

SeriesHE.iter_group_items(*, axis).apply(func, *, dtype, name, index_constructor)

iter_group_items

IterNodeDelegate.apply(func: Callable[[...], Any], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a function to each value. Returns a new container.

Parameters

func – A function that takes a value.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_group_items(*, axis).apply_iter(func)

iter_group_items

IterNodeDelegate.apply_iter(func: Callable[[...], Any]) → Iterator[Any][source]

Apply a function to each value. A generator of resulting values.

Parameters: func – A function that takes a value.

SeriesHE.iter_group_items(*, axis).apply_iter_items(func)

iter_group_items

IterNodeDelegate.apply_iter_items(func: Callable[[...], Any]) → Iterator[Tuple[Any, Any]][source]

Apply a function to each value. A generator of resulting key, value pairs.

Parameters: func – A function that takes a value.

SeriesHE.iter_group_items(*, axis).apply_pool(func, *, dtype, name, index_constructor, max_workers, chunksize, use_threads)

iter_group_items

IterNodeDelegate.apply_pool(func: Callable[[...], Any], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None, max_workers: Optional[int] = None, chunksize: int = 1, use_threads: bool = False) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a function to each value. Employ parallel processing with either the ProcessPoolExecutor or ThreadPoolExecutor.

Parameters

func – A function that takes a value.
* –
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.
name – A hashable object to label the container.
max_workers – Number of parallel executors, as passed to the Thread- or ProcessPoolExecutor; None defaults to the max number of machine processes.
chunksize – Units of work per executor, as passed to the Thread- or ProcessPoolExecutor.
use_threads – Use the ThreadPoolExecutor instead of the ProcessPoolExecutor.

SeriesHE.iter_group_items(*, axis).map_all(mapping, *, dtype, name, index_constructor)

iter_group_items

IterNodeDelegate.map_all(mapping: Union[Mapping[Hashable, Any], Series], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, an Exception is raised. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_group_items(*, axis).map_all_iter(mapping)

iter_group_items

IterNodeDelegate.map_all_iter(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, an Exception is raised. A generator of resulting values.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_group_items(*, axis).map_all_iter_items(mapping)

iter_group_items

IterNodeDelegate.map_all_iter_items(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, an Exception is raised. A generator of resulting key, value pairs.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_group_items(*, axis).map_any(mapping, *, dtype, name, index_constructor)

iter_group_items

IterNodeDelegate.map_any(mapping: Union[Mapping[Hashable, Any], Series], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, the value is returned. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_group_items(*, axis).map_any_iter(mapping)

iter_group_items

IterNodeDelegate.map_any_iter(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, the value is returned. A generator of resulting values.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_group_items(*, axis).map_any_iter_items(mapping)

iter_group_items

IterNodeDelegate.map_any_iter_items(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, the value is returned. A generator of resulting key, value pairs.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_group_items(*, axis).map_fill(mapping, *, fill_value, dtype, name, index_constructor)

iter_group_items

IterNodeDelegate.map_fill(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, the fill_value is returned. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_group_items(*, axis).map_fill_iter(mapping, *, fill_value)

iter_group_items

IterNodeDelegate.map_fill_iter(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, the fill_value is returned. A generator of resulting values.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.

SeriesHE.iter_group_items(*, axis).map_fill_iter_items(mapping, *, fill_value)

iter_group_items

IterNodeDelegate.map_fill_iter_items(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, the fill_value is returned. A generator of resulting key, value pairs.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.

SeriesHE.iter_group_labels(depth_level)

iter_group_labels

SeriesHE.iter_group_labels(depth_level).apply(func, *, dtype, name, index_constructor)

iter_group_labels

IterNodeDelegate.apply(func: Callable[[...], Any], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a function to each value. Returns a new container.

Parameters

func – A function that takes a value.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_group_labels(depth_level).apply_iter(func)

iter_group_labels

IterNodeDelegate.apply_iter(func: Callable[[...], Any]) → Iterator[Any][source]

Apply a function to each value. A generator of resulting values.

Parameters: func – A function that takes a value.

SeriesHE.iter_group_labels(depth_level).apply_iter_items(func)

iter_group_labels

IterNodeDelegate.apply_iter_items(func: Callable[[...], Any]) → Iterator[Tuple[Any, Any]][source]

Apply a function to each value. A generator of resulting key, value pairs.

Parameters: func – A function that takes a value.

SeriesHE.iter_group_labels(depth_level).apply_pool(func, *, dtype, name, index_constructor, max_workers, chunksize, use_threads)

iter_group_labels

IterNodeDelegate.apply_pool(func: Callable[[...], Any], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None, max_workers: Optional[int] = None, chunksize: int = 1, use_threads: bool = False) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a function to each value. Employ parallel processing with either the ProcessPoolExecutor or ThreadPoolExecutor.

Parameters

func – A function that takes a value.
* –
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.
name – A hashable object to label the container.
max_workers – Number of parallel executors, as passed to the Thread- or ProcessPoolExecutor; None defaults to the max number of machine processes.
chunksize – Units of work per executor, as passed to the Thread- or ProcessPoolExecutor.
use_threads – Use the ThreadPoolExecutor instead of the ProcessPoolExecutor.

SeriesHE.iter_group_labels(depth_level).map_all(mapping, *, dtype, name, index_constructor)

iter_group_labels

IterNodeDelegate.map_all(mapping: Union[Mapping[Hashable, Any], Series], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, an Exception is raised. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_group_labels(depth_level).map_all_iter(mapping)

iter_group_labels

IterNodeDelegate.map_all_iter(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, an Exception is raised. A generator of resulting values.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_group_labels(depth_level).map_all_iter_items(mapping)

iter_group_labels

IterNodeDelegate.map_all_iter_items(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, an Exception is raised. A generator of resulting key, value pairs.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_group_labels(depth_level).map_any(mapping, *, dtype, name, index_constructor)

iter_group_labels

IterNodeDelegate.map_any(mapping: Union[Mapping[Hashable, Any], Series], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, the value is returned. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_group_labels(depth_level).map_any_iter(mapping)

iter_group_labels

IterNodeDelegate.map_any_iter(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, the value is returned. A generator of resulting values.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_group_labels(depth_level).map_any_iter_items(mapping)

iter_group_labels

IterNodeDelegate.map_any_iter_items(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, the value is returned. A generator of resulting key, value pairs.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_group_labels(depth_level).map_fill(mapping, *, fill_value, dtype, name, index_constructor)

iter_group_labels

IterNodeDelegate.map_fill(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, the fill_value is returned. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_group_labels(depth_level).map_fill_iter(mapping, *, fill_value)

iter_group_labels

IterNodeDelegate.map_fill_iter(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, the fill_value is returned. A generator of resulting values.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.

SeriesHE.iter_group_labels(depth_level).map_fill_iter_items(mapping, *, fill_value)

iter_group_labels

IterNodeDelegate.map_fill_iter_items(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, the fill_value is returned. A generator of resulting key, value pairs.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.

SeriesHE.iter_group_labels_items(depth_level)

iter_group_labels_items

SeriesHE.iter_group_labels_items(depth_level).apply(func, *, dtype, name, index_constructor)

iter_group_labels_items

IterNodeDelegate.apply(func: Callable[[...], Any], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a function to each value. Returns a new container.

Parameters

func – A function that takes a value.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_group_labels_items(depth_level).apply_iter(func)

iter_group_labels_items

IterNodeDelegate.apply_iter(func: Callable[[...], Any]) → Iterator[Any][source]

Apply a function to each value. A generator of resulting values.

Parameters: func – A function that takes a value.

SeriesHE.iter_group_labels_items(depth_level).apply_iter_items(func)

iter_group_labels_items

IterNodeDelegate.apply_iter_items(func: Callable[[...], Any]) → Iterator[Tuple[Any, Any]][source]

Apply a function to each value. A generator of resulting key, value pairs.

Parameters: func – A function that takes a value.

SeriesHE.iter_group_labels_items(depth_level).apply_pool(func, *, dtype, name, index_constructor, max_workers, chunksize, use_threads)

iter_group_labels_items

IterNodeDelegate.apply_pool(func: Callable[[...], Any], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None, max_workers: Optional[int] = None, chunksize: int = 1, use_threads: bool = False) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a function to each value. Employ parallel processing with either the ProcessPoolExecutor or ThreadPoolExecutor.

Parameters

func – A function that takes a value.
* –
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.
name – A hashable object to label the container.
max_workers – Number of parallel executors, as passed to the Thread- or ProcessPoolExecutor; None defaults to the max number of machine processes.
chunksize – Units of work per executor, as passed to the Thread- or ProcessPoolExecutor.
use_threads – Use the ThreadPoolExecutor instead of the ProcessPoolExecutor.

SeriesHE.iter_group_labels_items(depth_level).map_all(mapping, *, dtype, name, index_constructor)

iter_group_labels_items

IterNodeDelegate.map_all(mapping: Union[Mapping[Hashable, Any], Series], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, an Exception is raised. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_group_labels_items(depth_level).map_all_iter(mapping)

iter_group_labels_items

IterNodeDelegate.map_all_iter(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, an Exception is raised. A generator of resulting values.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_group_labels_items(depth_level).map_all_iter_items(mapping)

iter_group_labels_items

IterNodeDelegate.map_all_iter_items(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, an Exception is raised. A generator of resulting key, value pairs.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_group_labels_items(depth_level).map_any(mapping, *, dtype, name, index_constructor)

iter_group_labels_items

IterNodeDelegate.map_any(mapping: Union[Mapping[Hashable, Any], Series], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, the value is returned. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_group_labels_items(depth_level).map_any_iter(mapping)

iter_group_labels_items

IterNodeDelegate.map_any_iter(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, the value is returned. A generator of resulting values.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_group_labels_items(depth_level).map_any_iter_items(mapping)

iter_group_labels_items

IterNodeDelegate.map_any_iter_items(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, the value is returned. A generator of resulting key, value pairs.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_group_labels_items(depth_level).map_fill(mapping, *, fill_value, dtype, name, index_constructor)

iter_group_labels_items

IterNodeDelegate.map_fill(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, the fill_value is returned. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_group_labels_items(depth_level).map_fill_iter(mapping, *, fill_value)

iter_group_labels_items

IterNodeDelegate.map_fill_iter(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, the fill_value is returned. A generator of resulting values.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.

SeriesHE.iter_group_labels_items(depth_level).map_fill_iter_items(mapping, *, fill_value)

iter_group_labels_items

IterNodeDelegate.map_fill_iter_items(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, the fill_value is returned. A generator of resulting key, value pairs.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.

SeriesHE.iter_window(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment)

iter_window

SeriesHE.iter_window(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply(func, *, dtype, name, index_constructor)

iter_window

IterNodeDelegate.apply(func: Callable[[...], Any], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a function to each value. Returns a new container.

Parameters

func – A function that takes a value.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_window(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply_iter(func)

iter_window

IterNodeDelegate.apply_iter(func: Callable[[...], Any]) → Iterator[Any][source]

Apply a function to each value. A generator of resulting values.

Parameters: func – A function that takes a value.

SeriesHE.iter_window(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply_iter_items(func)

iter_window

IterNodeDelegate.apply_iter_items(func: Callable[[...], Any]) → Iterator[Tuple[Any, Any]][source]

Apply a function to each value. A generator of resulting key, value pairs.

Parameters: func – A function that takes a value.

SeriesHE.iter_window(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply_pool(func, *, dtype, name, index_constructor, max_workers, chunksize, use_threads)

iter_window

IterNodeDelegate.apply_pool(func: Callable[[...], Any], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None, max_workers: Optional[int] = None, chunksize: int = 1, use_threads: bool = False) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a function to each value. Employ parallel processing with either the ProcessPoolExecutor or ThreadPoolExecutor.

Parameters

func – A function that takes a value.
* –
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.
name – A hashable object to label the container.
max_workers – Number of parallel executors, as passed to the Thread- or ProcessPoolExecutor; None defaults to the max number of machine processes.
chunksize – Units of work per executor, as passed to the Thread- or ProcessPoolExecutor.
use_threads – Use the ThreadPoolExecutor instead of the ProcessPoolExecutor.

SeriesHE.iter_window(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_all(mapping, *, dtype, name, index_constructor)

iter_window

IterNodeDelegate.map_all(mapping: Union[Mapping[Hashable, Any], Series], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, an Exception is raised. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_window(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_all_iter(mapping)

iter_window

IterNodeDelegate.map_all_iter(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, an Exception is raised. A generator of resulting values.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_window(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_all_iter_items(mapping)

iter_window

IterNodeDelegate.map_all_iter_items(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, an Exception is raised. A generator of resulting key, value pairs.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_window(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_any(mapping, *, dtype, name, index_constructor)

iter_window

IterNodeDelegate.map_any(mapping: Union[Mapping[Hashable, Any], Series], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, the value is returned. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_window(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_any_iter(mapping)

iter_window

IterNodeDelegate.map_any_iter(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, the value is returned. A generator of resulting values.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_window(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_any_iter_items(mapping)

iter_window

IterNodeDelegate.map_any_iter_items(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, the value is returned. A generator of resulting key, value pairs.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_window(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_fill(mapping, *, fill_value, dtype, name, index_constructor)

iter_window

IterNodeDelegate.map_fill(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, the fill_value is returned. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_window(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_fill_iter(mapping, *, fill_value)

iter_window

IterNodeDelegate.map_fill_iter(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, the fill_value is returned. A generator of resulting values.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.

SeriesHE.iter_window(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_fill_iter_items(mapping, *, fill_value)

iter_window

IterNodeDelegate.map_fill_iter_items(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, the fill_value is returned. A generator of resulting key, value pairs.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.

SeriesHE.iter_window_array(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment)

iter_window_array

SeriesHE.iter_window_array(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply(func, *, dtype, name, index_constructor)

iter_window_array

IterNodeDelegate.apply(func: Callable[[...], Any], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a function to each value. Returns a new container.

Parameters

func – A function that takes a value.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_window_array(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply_iter(func)

iter_window_array

IterNodeDelegate.apply_iter(func: Callable[[...], Any]) → Iterator[Any][source]

Apply a function to each value. A generator of resulting values.

Parameters: func – A function that takes a value.

SeriesHE.iter_window_array(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply_iter_items(func)

iter_window_array

IterNodeDelegate.apply_iter_items(func: Callable[[...], Any]) → Iterator[Tuple[Any, Any]][source]

Apply a function to each value. A generator of resulting key, value pairs.

Parameters: func – A function that takes a value.

SeriesHE.iter_window_array(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply_pool(func, *, dtype, name, index_constructor, max_workers, chunksize, use_threads)

iter_window_array

IterNodeDelegate.apply_pool(func: Callable[[...], Any], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None, max_workers: Optional[int] = None, chunksize: int = 1, use_threads: bool = False) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a function to each value. Employ parallel processing with either the ProcessPoolExecutor or ThreadPoolExecutor.

Parameters

func – A function that takes a value.
* –
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.
name – A hashable object to label the container.
max_workers – Number of parallel executors, as passed to the Thread- or ProcessPoolExecutor; None defaults to the max number of machine processes.
chunksize – Units of work per executor, as passed to the Thread- or ProcessPoolExecutor.
use_threads – Use the ThreadPoolExecutor instead of the ProcessPoolExecutor.

SeriesHE.iter_window_array(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_all(mapping, *, dtype, name, index_constructor)

iter_window_array

IterNodeDelegate.map_all(mapping: Union[Mapping[Hashable, Any], Series], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, an Exception is raised. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_window_array(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_all_iter(mapping)

iter_window_array

IterNodeDelegate.map_all_iter(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, an Exception is raised. A generator of resulting values.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_window_array(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_all_iter_items(mapping)

iter_window_array

IterNodeDelegate.map_all_iter_items(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, an Exception is raised. A generator of resulting key, value pairs.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_window_array(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_any(mapping, *, dtype, name, index_constructor)

iter_window_array

IterNodeDelegate.map_any(mapping: Union[Mapping[Hashable, Any], Series], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, the value is returned. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_window_array(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_any_iter(mapping)

iter_window_array

IterNodeDelegate.map_any_iter(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, the value is returned. A generator of resulting values.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_window_array(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_any_iter_items(mapping)

iter_window_array

IterNodeDelegate.map_any_iter_items(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, the value is returned. A generator of resulting key, value pairs.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_window_array(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_fill(mapping, *, fill_value, dtype, name, index_constructor)

iter_window_array

IterNodeDelegate.map_fill(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, the fill_value is returned. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_window_array(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_fill_iter(mapping, *, fill_value)

iter_window_array

IterNodeDelegate.map_fill_iter(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, the fill_value is returned. A generator of resulting values.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.

SeriesHE.iter_window_array(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_fill_iter_items(mapping, *, fill_value)

iter_window_array

IterNodeDelegate.map_fill_iter_items(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, the fill_value is returned. A generator of resulting key, value pairs.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.

SeriesHE.iter_window_array_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment)

iter_window_array_items

SeriesHE.iter_window_array_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply(func, *, dtype, name, index_constructor)

iter_window_array_items

IterNodeDelegate.apply(func: Callable[[...], Any], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a function to each value. Returns a new container.

Parameters

func – A function that takes a value.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_window_array_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply_iter(func)

iter_window_array_items

IterNodeDelegate.apply_iter(func: Callable[[...], Any]) → Iterator[Any][source]

Apply a function to each value. A generator of resulting values.

Parameters: func – A function that takes a value.

SeriesHE.iter_window_array_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply_iter_items(func)

iter_window_array_items

IterNodeDelegate.apply_iter_items(func: Callable[[...], Any]) → Iterator[Tuple[Any, Any]][source]

Apply a function to each value. A generator of resulting key, value pairs.

Parameters: func – A function that takes a value.

SeriesHE.iter_window_array_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply_pool(func, *, dtype, name, index_constructor, max_workers, chunksize, use_threads)

iter_window_array_items

IterNodeDelegate.apply_pool(func: Callable[[...], Any], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None, max_workers: Optional[int] = None, chunksize: int = 1, use_threads: bool = False) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a function to each value. Employ parallel processing with either the ProcessPoolExecutor or ThreadPoolExecutor.

Parameters

func – A function that takes a value.
* –
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.
name – A hashable object to label the container.
max_workers – Number of parallel executors, as passed to the Thread- or ProcessPoolExecutor; None defaults to the max number of machine processes.
chunksize – Units of work per executor, as passed to the Thread- or ProcessPoolExecutor.
use_threads – Use the ThreadPoolExecutor instead of the ProcessPoolExecutor.

SeriesHE.iter_window_array_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_all(mapping, *, dtype, name, index_constructor)

iter_window_array_items

IterNodeDelegate.map_all(mapping: Union[Mapping[Hashable, Any], Series], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, an Exception is raised. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_window_array_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_all_iter(mapping)

iter_window_array_items

IterNodeDelegate.map_all_iter(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, an Exception is raised. A generator of resulting values.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_window_array_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_all_iter_items(mapping)

iter_window_array_items

IterNodeDelegate.map_all_iter_items(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, an Exception is raised. A generator of resulting key, value pairs.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_window_array_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_any(mapping, *, dtype, name, index_constructor)

iter_window_array_items

IterNodeDelegate.map_any(mapping: Union[Mapping[Hashable, Any], Series], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, the value is returned. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_window_array_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_any_iter(mapping)

iter_window_array_items

IterNodeDelegate.map_any_iter(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, the value is returned. A generator of resulting values.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_window_array_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_any_iter_items(mapping)

iter_window_array_items

IterNodeDelegate.map_any_iter_items(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, the value is returned. A generator of resulting key, value pairs.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_window_array_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_fill(mapping, *, fill_value, dtype, name, index_constructor)

iter_window_array_items

IterNodeDelegate.map_fill(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, the fill_value is returned. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_window_array_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_fill_iter(mapping, *, fill_value)

iter_window_array_items

IterNodeDelegate.map_fill_iter(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, the fill_value is returned. A generator of resulting values.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.

SeriesHE.iter_window_array_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_fill_iter_items(mapping, *, fill_value)

iter_window_array_items

IterNodeDelegate.map_fill_iter_items(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, the fill_value is returned. A generator of resulting key, value pairs.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.

SeriesHE.iter_window_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment)

iter_window_items

SeriesHE.iter_window_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply(func, *, dtype, name, index_constructor)

iter_window_items

IterNodeDelegate.apply(func: Callable[[...], Any], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a function to each value. Returns a new container.

Parameters

func – A function that takes a value.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_window_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply_iter(func)

iter_window_items

IterNodeDelegate.apply_iter(func: Callable[[...], Any]) → Iterator[Any][source]

Apply a function to each value. A generator of resulting values.

Parameters: func – A function that takes a value.

SeriesHE.iter_window_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply_iter_items(func)

iter_window_items

IterNodeDelegate.apply_iter_items(func: Callable[[...], Any]) → Iterator[Tuple[Any, Any]][source]

Apply a function to each value. A generator of resulting key, value pairs.

Parameters: func – A function that takes a value.

SeriesHE.iter_window_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply_pool(func, *, dtype, name, index_constructor, max_workers, chunksize, use_threads)

iter_window_items

IterNodeDelegate.apply_pool(func: Callable[[...], Any], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None, max_workers: Optional[int] = None, chunksize: int = 1, use_threads: bool = False) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a function to each value. Employ parallel processing with either the ProcessPoolExecutor or ThreadPoolExecutor.

Parameters

func – A function that takes a value.
* –
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.
name – A hashable object to label the container.
max_workers – Number of parallel executors, as passed to the Thread- or ProcessPoolExecutor; None defaults to the max number of machine processes.
chunksize – Units of work per executor, as passed to the Thread- or ProcessPoolExecutor.
use_threads – Use the ThreadPoolExecutor instead of the ProcessPoolExecutor.

SeriesHE.iter_window_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_all(mapping, *, dtype, name, index_constructor)

iter_window_items

IterNodeDelegate.map_all(mapping: Union[Mapping[Hashable, Any], Series], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, an Exception is raised. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_window_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_all_iter(mapping)

iter_window_items

IterNodeDelegate.map_all_iter(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, an Exception is raised. A generator of resulting values.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_window_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_all_iter_items(mapping)

iter_window_items

IterNodeDelegate.map_all_iter_items(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, an Exception is raised. A generator of resulting key, value pairs.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_window_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_any(mapping, *, dtype, name, index_constructor)

iter_window_items

IterNodeDelegate.map_any(mapping: Union[Mapping[Hashable, Any], Series], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, the value is returned. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_window_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_any_iter(mapping)

iter_window_items

IterNodeDelegate.map_any_iter(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, the value is returned. A generator of resulting values.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_window_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_any_iter_items(mapping)

iter_window_items

IterNodeDelegate.map_any_iter_items(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, the value is returned. A generator of resulting key, value pairs.

Parameters: mapping – A mapping type, such as a dictionary or Series.

SeriesHE.iter_window_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_fill(mapping, *, fill_value, dtype, name, index_constructor)

iter_window_items

IterNodeDelegate.map_fill(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None) → static_frame.core.node_iter.FrameOrSeries[source]

Apply a mapping; for values not in the mapping, the fill_value is returned. Returns a new container.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.
dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

SeriesHE.iter_window_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_fill_iter(mapping, *, fill_value)

iter_window_items

IterNodeDelegate.map_fill_iter(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, the fill_value is returned. A generator of resulting values.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.

SeriesHE.iter_window_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_fill_iter_items(mapping, *, fill_value)

iter_window_items

IterNodeDelegate.map_fill_iter_items(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, the fill_value is returned. A generator of resulting key, value pairs.

Parameters

mapping – A mapping type, such as a dictionary or Series.
fill_value – Value to be returned if the values is not a key in the mapping.

SeriesHE: Operator Binary¶

Overview: SeriesHE: Operator Binary

SeriesHE.__add__(other: Any) → Any

SeriesHE.__and__(other: Any) → Any

SeriesHE.__eq__(other: Any) → bool[source]: Return True if other is a Series with the same labels, values, and name. Container class and underlying dtypes are not independently compared.

SeriesHE.__floordiv__(other: Any) → Any

SeriesHE.__ge__(other: Any) → Any: Return self>=value.

SeriesHE.__gt__(other: Any) → Any: Return self>value.

SeriesHE.__le__(other: Any) → Any: Return self<=value.

SeriesHE.__lt__(other: Any) → Any: Return self<value.

SeriesHE.__matmul__(other: Any) → Any

SeriesHE.__mod__(other: Any) → Any

SeriesHE.__mul__(other: Any) → Any

SeriesHE.__ne__(other: Any) → bool[source]: Return False if other is a Series with the same labels, values, and name. Container class and underlying dtypes are not independently compared.

SeriesHE.__or__(other: Any) → Any

SeriesHE.__pow__(other: Any) → Any

SeriesHE.__radd__(other: Any) → Any

SeriesHE.__rfloordiv__(other: Any) → Any

SeriesHE.__rmatmul__(other: Any) → Any

SeriesHE.__rmul__(other: Any) → Any

SeriesHE.__rshift__(other: Any) → Any

SeriesHE.__rsub__(other: Any) → Any

SeriesHE.__rtruediv__(other: Any) → Any

SeriesHE.__sub__(other: Any) → Any

SeriesHE.__truediv__(other: Any) → Any

SeriesHE.__xor__(other: Any) → Any

SeriesHE: Operator Unary¶

Overview: SeriesHE: Operator Unary

SeriesHE.__abs__() → static_frame.core.container.ContainerOperand

SeriesHE.__invert__() → static_frame.core.container.ContainerOperand

SeriesHE.__neg__() → static_frame.core.container.ContainerOperand

SeriesHE.__pos__() → static_frame.core.container.ContainerOperand

SeriesHE: Accessor Datetime¶

Overview: SeriesHE: Accessor Datetime

SeriesHE.via_dt.year

SeriesHE.via_dt: Interface for applying datetime properties and methods to elements in this container.

InterfaceDatetime.year: Return the year of each element.

SeriesHE.via_dt.month

SeriesHE.via_dt: Interface for applying datetime properties and methods to elements in this container.

InterfaceDatetime.month: Return the month of each element, between 1 and 12 inclusive.

SeriesHE.via_dt.day

SeriesHE.via_dt: Interface for applying datetime properties and methods to elements in this container.

InterfaceDatetime.day: Return the day of each element, between 1 and the number of days in the given month of the given year.

SeriesHE.via_dt.weekday

SeriesHE.via_dt: Interface for applying datetime properties and methods to elements in this container.

InterfaceDatetime.weekday() → static_frame.core.node_selector.TContainer[source]: Return the day of the week as an integer, where Monday is 0 and Sunday is 6.

SeriesHE.via_dt.timetuple

SeriesHE.via_dt: Interface for applying datetime properties and methods to elements in this container.

InterfaceDatetime.timetuple() → static_frame.core.node_selector.TContainer[source]: Return a time.struct_time such as returned by time.localtime().

SeriesHE.via_dt.fromisoformat

SeriesHE.via_dt: Interface for applying datetime properties and methods to elements in this container.

InterfaceDatetime.fromisoformat() → static_frame.core.node_selector.TContainer[source]: Return a datetime.date object from an ISO 8601 format.

SeriesHE.via_dt.isoformat(sep, timespec)

SeriesHE.via_dt: Interface for applying datetime properties and methods to elements in this container.

InterfaceDatetime.isoformat(sep: str = 'T', timespec: str = 'auto') → static_frame.core.node_selector.TContainer[source]: Return a string representing the date in ISO 8601 format, YYYY-MM-DD.

SeriesHE.via_dt.strftime(format)

SeriesHE.via_dt: Interface for applying datetime properties and methods to elements in this container.

InterfaceDatetime.strftime(format: str) → static_frame.core.node_selector.TContainer[source]: Return a string representing the date, controlled by an explicit format string.

SeriesHE.via_dt.strptime(format)

SeriesHE.via_dt: Interface for applying datetime properties and methods to elements in this container.

InterfaceDatetime.strptime(format: str) → static_frame.core.node_selector.TContainer[source]: Return a Python datetime object from parsing a string defined with format.

SeriesHE.via_dt.strpdate(format)

SeriesHE.via_dt: Interface for applying datetime properties and methods to elements in this container.

InterfaceDatetime.strpdate(format: str) → static_frame.core.node_selector.TContainer[source]: Return a Python date object from parsing a string defined with format.

SeriesHE: Accessor String¶

Overview: SeriesHE: Accessor String

SeriesHE.via_str.__getitem__(key)

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.__getitem__(key: Union[int, numpy.integer, slice, List[Any], None, Index, Series, numpy.ndarray]) → static_frame.core.node_selector.TContainer[source]: Return a container with the provided selection or slice of each element.

SeriesHE.via_str.capitalize

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.capitalize() → static_frame.core.node_selector.TContainer[source]: Return a container with only the first character of each element capitalized.

SeriesHE.via_str.center(width, fillchar)

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.center(width: int, fillchar: str = ' ') → static_frame.core.node_selector.TContainer[source]: Return a container with its elements centered in a string of length width.

SeriesHE.via_str.count(sub, start, end)

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.count(sub: str, start: Optional[int] = None, end: Optional[int] = None) → static_frame.core.node_selector.TContainer[source]: Returns a container with the number of non-overlapping occurrences of substring sub in the optional range start, end.

SeriesHE.via_str.decode(encoding, errors)

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.decode(encoding: Optional[str] = None, errors: Optional[str] = None) → static_frame.core.node_selector.TContainer[source]: Apply str.decode() to each element. Elements must be bytes.

SeriesHE.via_str.encode(encoding, errors)

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.encode(encoding: Optional[str] = None, errors: Optional[str] = None) → static_frame.core.node_selector.TContainer[source]: Apply str.encode() to each element. Elements must be strings.

SeriesHE.via_str.endswith(suffix, start, end)

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.endswith(suffix: Union[str, Iterable[str]], start: Optional[int] = None, end: Optional[int] = None) → static_frame.core.node_selector.TContainer[source]: Returns a container with the number of non-overlapping occurrences of substring suffix (or an interable of suffixes) in the optional range start, end.

SeriesHE.via_str.find(sub, start, end)

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.find(sub: str, start: Optional[int] = None, end: Optional[int] = None) → static_frame.core.node_selector.TContainer[source]: For each element, return the lowest index in the string where substring sub is found.

SeriesHE.via_str.index(sub, start, end)

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.index(sub: str, start: Optional[int] = None, end: Optional[int] = None) → static_frame.core.node_selector.TContainer[source]: Like find, but raises ValueError when the substring is not found.

SeriesHE.via_str.isalnum

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.isalnum() → static_frame.core.node_selector.TContainer[source]: Returns true for each element if all characters in the string are alphanumeric and there is at least one character, false otherwise.

SeriesHE.via_str.isalpha

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.isalpha() → static_frame.core.node_selector.TContainer[source]: Returns true for each element if all characters in the string are alphabetic and there is at least one character, false otherwise.

SeriesHE.via_str.isdecimal

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.isdecimal() → static_frame.core.node_selector.TContainer[source]: For each element, return True if there are only decimal characters in the element.

SeriesHE.via_str.isdigit

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.isdigit() → static_frame.core.node_selector.TContainer[source]: Returns true for each element if all characters in the string are digits and there is at least one character, false otherwise.

SeriesHE.via_str.islower

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.islower() → static_frame.core.node_selector.TContainer[source]: Returns true for each element if all cased characters in the string are lowercase and there is at least one cased character, false otherwise.

SeriesHE.via_str.isnumeric

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.isnumeric() → static_frame.core.node_selector.TContainer[source]: For each element in self, return True if there are only numeric characters in the element.

SeriesHE.via_str.isspace

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.isspace() → static_frame.core.node_selector.TContainer[source]: Returns true for each element if there are only whitespace characters in the string and there is at least one character, false otherwise.

SeriesHE.via_str.istitle

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.istitle() → static_frame.core.node_selector.TContainer[source]: Returns true for each element if the element is a titlecased string and there is at least one character, false otherwise.

SeriesHE.via_str.isupper

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.isupper() → static_frame.core.node_selector.TContainer[source]: Returns true for each element if all cased characters in the string are uppercase and there is at least one character, false otherwise.

SeriesHE.via_str.ljust(width, fillchar)

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.ljust(width: int, fillchar: str = ' ') → static_frame.core.node_selector.TContainer[source]: Return a container with its elements ljusted in a string of length width.

SeriesHE.via_str.len

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.len() → static_frame.core.node_selector.TContainer[source]: Return the length of the string.

SeriesHE.via_str.lower

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.lower() → static_frame.core.node_selector.TContainer[source]: Return an array with the elements of self converted to lowercase.

SeriesHE.via_str.lstrip(chars)

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.lstrip(chars: Optional[str] = None) → static_frame.core.node_selector.TContainer[source]: For each element, return a copy with the leading characters removed.

SeriesHE.via_str.partition(sep)

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.partition(sep: str) → static_frame.core.node_selector.TContainer[source]: Partition each element around sep.

SeriesHE.via_str.replace(old, new, count)

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.replace(old: str, new: str, count: Optional[int] = None) → static_frame.core.node_selector.TContainer[source]: Return a container with its elements replaced in a string of length width.

SeriesHE.via_str.rfind(sub, start, end)

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.rfind(sub: str, start: Optional[int] = None, end: Optional[int] = None) → static_frame.core.node_selector.TContainer[source]: For each element, return the highest index in the string where substring sub is found, such that sub is contained within start, end.

SeriesHE.via_str.rindex(sub, start, end)

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.rindex(sub: str, start: Optional[int] = None, end: Optional[int] = None) → static_frame.core.node_selector.TContainer[source]: Like rfind, but raises ValueError when the substring sub is not found.

SeriesHE.via_str.rjust(width, fillchar)

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.rjust(width: int, fillchar: str = ' ') → static_frame.core.node_selector.TContainer[source]: Return a container with its elements rjusted in a string of length width.

SeriesHE.via_str.rpartition(sep)

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.rpartition(sep: str) → static_frame.core.node_selector.TContainer[source]: Partition (split) each element around the right-most separator.

SeriesHE.via_str.rsplit(sep, maxsplit)

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.rsplit(sep: str, maxsplit: int = - 1) → static_frame.core.node_selector.TContainer[source]: For each element, return a tuple of the words in the string, using sep as the delimiter string.

SeriesHE.via_str.rstrip(chars)

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.rstrip(chars: Optional[str] = None) → static_frame.core.node_selector.TContainer[source]: For each element, return a copy with the trailing characters removed.

SeriesHE.via_str.split(sep, maxsplit)

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.split(sep: str, maxsplit: int = - 1) → static_frame.core.node_selector.TContainer[source]: For each element, return a tuple of the words in the string, using sep as the delimiter string.

SeriesHE.via_str.startswith(prefix, start, end)

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.startswith(prefix: Union[str, Iterable[str]], start: Optional[int] = None, end: Optional[int] = None) → static_frame.core.node_selector.TContainer[source]: Returns a container with the number of non-overlapping occurrences of substring prefix (or an interable of prefixes) in the optional range start, end.

SeriesHE.via_str.strip(chars)

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.strip(chars: Optional[str] = None) → static_frame.core.node_selector.TContainer[source]: For each element, return a copy with the leading and trailing characters removed.

SeriesHE.via_str.swapcase

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.swapcase() → static_frame.core.node_selector.TContainer[source]: Return a container with uppercase characters converted to lowercase and vice versa.

SeriesHE.via_str.title

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.title() → static_frame.core.node_selector.TContainer[source]: Return a container with uppercase characters converted to lowercase and vice versa.

SeriesHE.via_str.upper

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.upper() → static_frame.core.node_selector.TContainer[source]: Return a container with uppercase characters converted to lowercase and vice versa.

SeriesHE.via_str.zfill(width)

SeriesHE.via_str: Interface for applying string methods to elements in this container.

InterfaceString.zfill(width: int) → static_frame.core.node_selector.TContainer[source]: Return the string left-filled with zeros.

SeriesHE: Accessor Fill Value¶

Overview: SeriesHE: Accessor Fill Value

SeriesHE.via_fill_value(fill_value).via_T

SeriesHE.via_fill_value = <function Series.via_fill_value>

InterfaceFillValue.via_T: Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

SeriesHE.via_fill_value(fill_value).__add__(other)

via_fill_value = <function Series.via_fill_value>

InterfaceFillValue.__add__(other: Any) → Any[source]

SeriesHE.via_fill_value(fill_value).__sub__(other)

via_fill_value = <function Series.via_fill_value>

InterfaceFillValue.__sub__(other: Any) → Any[source]

SeriesHE.via_fill_value(fill_value).__mul__(other)

via_fill_value = <function Series.via_fill_value>

InterfaceFillValue.__mul__(other: Any) → Any[source]

SeriesHE.via_fill_value(fill_value).__truediv__(other)

via_fill_value = <function Series.via_fill_value>

InterfaceFillValue.__truediv__(other: Any) → Any[source]

SeriesHE.via_fill_value(fill_value).__floordiv__(other)

via_fill_value = <function Series.via_fill_value>

InterfaceFillValue.__floordiv__(other: Any) → Any[source]

SeriesHE.via_fill_value(fill_value).__mod__(other)

via_fill_value = <function Series.via_fill_value>

InterfaceFillValue.__mod__(other: Any) → Any[source]

SeriesHE.via_fill_value(fill_value).__pow__(other)

via_fill_value = <function Series.via_fill_value>

InterfaceFillValue.__pow__(other: Any) → Any[source]

SeriesHE.via_fill_value(fill_value).__lshift__(other)

via_fill_value = <function Series.via_fill_value>

InterfaceFillValue.__lshift__(other: Any) → Any[source]

SeriesHE.via_fill_value(fill_value).__rshift__(other)

via_fill_value = <function Series.via_fill_value>

InterfaceFillValue.__rshift__(other: Any) → Any[source]

SeriesHE.via_fill_value(fill_value).__and__(other)

via_fill_value = <function Series.via_fill_value>

InterfaceFillValue.__and__(other: Any) → Any[source]

SeriesHE.via_fill_value(fill_value).__xor__(other)

via_fill_value = <function Series.via_fill_value>

InterfaceFillValue.__xor__(other: Any) → Any[source]

SeriesHE.via_fill_value(fill_value).__or__(other)

via_fill_value = <function Series.via_fill_value>

InterfaceFillValue.__or__(other: Any) → Any[source]

SeriesHE.via_fill_value(fill_value).__lt__(other)

via_fill_value = <function Series.via_fill_value>

InterfaceFillValue.__lt__(other: Any) → Any[source]: Return self<value.

SeriesHE.via_fill_value(fill_value).__le__(other)

via_fill_value = <function Series.via_fill_value>

InterfaceFillValue.__le__(other: Any) → Any[source]: Return self<=value.

SeriesHE.via_fill_value(fill_value).__eq__(other)

via_fill_value = <function Series.via_fill_value>

InterfaceFillValue.__eq__(other: Any) → Any[source]: Return self==value.

SeriesHE.via_fill_value(fill_value).__ne__(other)

via_fill_value = <function Series.via_fill_value>

InterfaceFillValue.__ne__(other: Any) → Any[source]: Return self!=value.

SeriesHE.via_fill_value(fill_value).__gt__(other)

via_fill_value = <function Series.via_fill_value>

InterfaceFillValue.__gt__(other: Any) → Any[source]: Return self>value.

SeriesHE.via_fill_value(fill_value).__ge__(other)

via_fill_value = <function Series.via_fill_value>

InterfaceFillValue.__ge__(other: Any) → Any[source]: Return self>=value.

SeriesHE.via_fill_value(fill_value).__radd__(other)

via_fill_value = <function Series.via_fill_value>

InterfaceFillValue.__radd__(other: Any) → Any[source]

SeriesHE.via_fill_value(fill_value).__rsub__(other)

via_fill_value = <function Series.via_fill_value>

InterfaceFillValue.__rsub__(other: Any) → Any[source]

SeriesHE.via_fill_value(fill_value).__rmul__(other)

via_fill_value = <function Series.via_fill_value>

InterfaceFillValue.__rmul__(other: Any) → Any[source]

SeriesHE.via_fill_value(fill_value).__rtruediv__(other)

via_fill_value = <function Series.via_fill_value>

InterfaceFillValue.__rtruediv__(other: Any) → Any[source]

SeriesHE.via_fill_value(fill_value).__rfloordiv__(other)

via_fill_value = <function Series.via_fill_value>

InterfaceFillValue.__rfloordiv__(other: Any) → Any[source]

SeriesHE: Accessor Regular Expression¶

Overview: SeriesHE: Accessor Regular Expression

SeriesHE.via_re(pattern, flags).search(pos, endpos)

via_re = <function Series.via_re>

InterfaceRe.search(pos: int = 0, endpos: Optional[int] = None) → static_frame.core.node_selector.TContainer[source]

Scan through string looking for the first location where this regular expression produces a match and return True, else False. Note that this is different from finding a zero-length match at some point in the string.

Parameters

pos – Gives an index in the string where the search is to start; it defaults to 0.
endpos – Limits how far the string will be searched; it will be as if the string is endpos characters long.

SeriesHE.via_re(pattern, flags).match(pos, endpos)

via_re = <function Series.via_re>

InterfaceRe.match(pos: int = 0, endpos: Optional[int] = None) → static_frame.core.node_selector.TContainer[source]

If zero or more characters at the beginning of string match this regular expression return True, else False. Note that this is different from a zero-length match.

Parameters

pos – Gives an index in the string where the search is to start; it defaults to 0.
endpos – Limits how far the string will be searched; it will be as if the string is endpos characters long.

SeriesHE.via_re(pattern, flags).fullmatch(pos, endpos)

via_re = <function Series.via_re>

InterfaceRe.fullmatch(pos: int = 0, endpos: Optional[int] = None) → static_frame.core.node_selector.TContainer[source]

If the whole string matches this regular expression, return True, else False. Note that this is different from a zero-length match.

Parameters

pos – Gives an index in the string where the search is to start; it defaults to 0.
endpos – Limits how far the string will be searched; it will be as if the string is endpos characters long.

SeriesHE.via_re(pattern, flags).split(maxsplit)

via_re = <function Series.via_re>

InterfaceRe.split(maxsplit: int = 0) → static_frame.core.node_selector.TContainer[source]

Split string by the occurrences of pattern. If capturing parentheses are used in pattern, then the text of all groups in the pattern are also returned as part of the resulting tuple.

Parameters: maxsplit – If nonzero, at most maxsplit splits occur, and the remainder of the string is returned as the final element of the tuple.

SeriesHE.via_re(pattern, flags).findall(pos, endpos)

via_re = <function Series.via_re>

InterfaceRe.findall(pos: int = 0, endpos: Optional[int] = None) → static_frame.core.node_selector.TContainer[source]

Return all non-overlapping matches of pattern in string, as a tuple of strings. The string is scanned left-to-right, and matches are returned in the order found. If one or more groups are present in the pattern, return a tuple of groups; this will be a tuple of tuples if the pattern has more than one group. Empty matches are included in the result.

Parameters

pos – Gives an index in the string where the search is to start; it defaults to 0.
endpos – Limits how far the string will be searched; it will be as if the string is endpos characters long.

SeriesHE.via_re(pattern, flags).sub(repl, count)

via_re = <function Series.via_re>

InterfaceRe.sub(repl: str, count: int = 0) → static_frame.core.node_selector.TContainer[source]

Return the string obtained by replacing the leftmost non-overlapping occurrences of pattern in string by the replacement repl. If the pattern is not found, the string is returned unchanged.

Parameters

repl – A string or a function; if it is a string, any backslash escapes in it are processed.
count – The optional argument count is the maximum number of pattern occurrences to be replaced; count must be a non-negative integer. If omitted or zero, all occurrences will be replaced.

SeriesHE.via_re(pattern, flags).subn(repl, count)

via_re = <function Series.via_re>

InterfaceRe.subn(repl: str, count: int = 0) → static_frame.core.node_selector.TContainer[source]

Perform the same operation as sub(), but return a tuple (new_string, number_of_subs_made).

Parameters

repl – A string or a function; if it is a string, any backslash escapes in it are processed.
count – The optional argument count is the maximum number of pattern occurrences to be replaced; count must be a non-negative integer. If omitted or zero, all occurrences will be replaced.