SeriesHE¶
Overview: 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 BooleanSeries
.
SeriesHE: Constructor¶
Overview: 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, index_constructor: Optional[Callable[[...], IndexBase]] = None, name: Optional[Hashable] = <object object>) Series
Concatenate multiple
Series
into a newSeries
.- Parameters
containers – Iterable of
Series
from which values in the newSeries
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.index_constructor –
name –
- Returns
- 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
. TheIndexHierarchy
is formed from the provided labels and theIndex
if eachSeries
.- Parameters
items – Iterable of pairs of label,
Series
- Returns
- 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
- 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 theindex
argument.- Returns
- 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
- 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, func: Callable[[numpy.ndarray], numpy.ndarray] = <function isna_array>, fill_value: Any = <object object>) static_frame.core.series.Series
Return a new
Series
made by overlaying containers, aligned values are filled with values from subsequent containers with left-to-right precedence. Values are filled based on a passed function that must return a Boolean array. By default, that function is isna_array, returning True for missing values (NaN and None).- Parameters
containers – Iterable of
Series
.*, –
index – An
Index
orIndexHierarchy
, 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 fromcontainers
will be used; if False, the intersection index will be used.name –
func –
fill_value –
- classmethod SeriesHE.from_pandas(value: pandas.Series, *, index: Optional[Union[IndexBase, Iterable[Hashable], Iterable[Sequence[Hashable]], Type[static_frame.core.index_auto.IndexAutoFactory]]] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None, name: Optional[Hashable] = <object object>, own_data: bool = False) Series
Given a Pandas Series, return a Series.
- Parameters
value – Pandas Series.
* –
index_constructor –
name –
own_data – If True, the underlying NumPy data array will be made immutable and used without a copy.
- Returns
SeriesHE: Constructor | Exporter | Attribute | Method | Dictionary-Like | Display | Assignment | Selector | Iterator | Operator Binary | Operator Unary | Accessor Datetime | Accessor String | Accessor Fill Value | Accessor Regular Expression
SeriesHE: Exporter¶
Overview: SeriesHE: Exporter
- SeriesHE.to_frame(axis: int = 1, *, index: Optional[Union[IndexBase, Iterable[Hashable], Iterable[Sequence[Hashable]], Type[static_frame.core.index_auto.IndexAutoFactory]]] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None, columns: Optional[Union[IndexBase, Iterable[Hashable], Iterable[Sequence[Hashable]], Type[static_frame.core.index_auto.IndexAutoFactory]]] = None, columns_constructor: Optional[Callable[[...], IndexBase]] = None) Frame
Return a
Frame
view of thisSeries
. As underlying data is immutable, this is a no-copy operation.
- SeriesHE.to_frame_go(axis: int = 1, *, index: Optional[Union[IndexBase, Iterable[Hashable], Iterable[Sequence[Hashable]], Type[static_frame.core.index_auto.IndexAutoFactory]]] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None, columns: Optional[Union[IndexBase, Iterable[Hashable], Iterable[Sequence[Hashable]], Type[static_frame.core.index_auto.IndexAutoFactory]]] = None, columns_constructor: Optional[Callable[[...], IndexBase]] = None) FrameGO
Return
FrameGO
view of thisSeries
. As underlying data is immutable, this is a no-copy operation.- Parameters
axis –
*, –
index_constructor –
columns_constructor –
- Returns
- SeriesHE.to_frame_he(axis: int = 1, *, index: Optional[Union[IndexBase, Iterable[Hashable], Iterable[Sequence[Hashable]], Type[static_frame.core.index_auto.IndexAutoFactory]]] = None, index_constructor: Optional[Callable[[...], IndexBase]] = None, columns: Optional[Union[IndexBase, Iterable[Hashable], Iterable[Sequence[Hashable]], Type[static_frame.core.index_auto.IndexAutoFactory]]] = None, columns_constructor: Optional[Callable[[...], IndexBase]] = None) FrameHE
Return
FrameHE
view of thisSeries
. As underlying data is immutable, this is a no-copy operation.- Parameters
axis –
*, –
index_constructor –
columns_constructor –
- Returns
- 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 thisSeriesHE
.
- SeriesHE.to_series_he() static_frame.core.series.SeriesHE
- SeriesHE.to_visidata() None
Open an interactive VisiData session.
SeriesHE: Constructor | Exporter | Attribute | Method | Dictionary-Like | Display | Assignment | Selector | Iterator | Operator Binary | Operator Unary | Accessor Datetime | Accessor String | Accessor Fill Value | Accessor Regular Expression
SeriesHE: Attribute¶
Overview: SeriesHE: Attribute
- SeriesHE.STATIC: bool = True
- SeriesHE.T
Transpose. For a 1D immutable container, this returns a reference to self.
- Returns
- SeriesHE.dtype
Return the dtype of the underlying NumPy array.
- Returns
numpy.dtype
- SeriesHE.index
The index instance assigned to this container.
- Returns
- 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: Constructor | Exporter | Attribute | Method | Dictionary-Like | Display | Assignment | Selector | Iterator | Operator Binary | Operator Unary | Accessor Datetime | Accessor String | Accessor Fill Value | Accessor Regular Expression
SeriesHE: Method¶
Overview: SeriesHE: Method
- SeriesHE.__array__(dtype: Optional[numpy.dtype] = None) numpy.ndarray
Support the __array__ interface, returning a 1D array of values.
- SeriesHE.__array_ufunc__(ufunc: Callable[[...], numpy.ndarray], method: str, *args: Any, **kwargs: Any) static_frame.core.container.ContainerOperand
Support for NumPy elements or arrays on the left hand of binary operators.
- 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
- 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
- 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
- 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
orskipfalsy
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
- 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. Thevalue
can be an element orSeries
.- 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. Thevalue
can be an element orSeries
.- 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 bycount
.
- 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 invalues
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 aSeries
at the position after the label specified bykey
.- Parameters
key – Label after which the new container will be inserted.
container – Container to be inserted.
- Returns
- SeriesHE.insert_before(key: Hashable, container: static_frame.core.series.Series) static_frame.core.series.Series
Create a new
Series
by inserting aSeries
at the position before the label specified bykey
.- Parameters
key – Label before which the new container will be inserted.
container – Container to be inserted.
- Returns
- 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
- 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 invalues
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 withfill_value
.ascending – If
True
, the lowest ranks correspond to the lowest values. The default isTrue
.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
isTrue
. The default isnp.nan
but can be set to any value to force NA values to the “bottom” or “top” of a rank as needed.
- Returns
- 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 withfill_value
.ascending – If
True
, the lowest ranks correspond to the lowest values. The default isTrue
.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
isTrue
. The default isnp.nan
but can be set to any value to force NA values to the “bottom” or “top” of a rank as needed.
- Returns
- 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 withfill_value
.ascending – If
True
, the lowest ranks correspond to the lowest values. The default isTrue
.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
isTrue
. The default isnp.nan
but can be set to any value to force NA values to the “bottom” or “top” of a rank as needed.
- Returns
- 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 withfill_value
.ascending – If
True
, the lowest ranks correspond to the lowest values. The default isTrue
.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
isTrue
. The default isnp.nan
but can be set to any value to force NA values to the “bottom” or “top” of a rank as needed.
- Returns
- 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 withfill_value
.ascending – If
True
, the lowest ranks correspond to the lowest values. The default isTrue
.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
isTrue
. The default isnp.nan
but can be set to any value to force NA values to the “bottom” or “top” of a rank as needed.
- Returns
- SeriesHE.rehierarch(depth_map: Sequence[int]) static_frame.core.series.Series
Return a new
Series
with new a hierarchy based on the supplieddepth_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 withfill_value
.- Parameters
index – An iterable of unique, hashable values, or another
Index
orIndexHierarchy
, to be used as the labels of the index.columns – An iterable of unique, hashable values, or another
Index
orIndexHierarchy
, 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]]]], *, index_constructor: Optional[Callable[[...], static_frame.core.index_base.IndexBase]] = None) 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 orSeries
), 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) TheIndexAutoFactory
type, to apply an auto-incremented integer index. (d) An index initializer, i.e., either an iterable of hashables or anIndex
instance.
- SeriesHE.relabel_flat() static_frame.core.series.Series
Return a new
Series
, where anIndexHierarchy
(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 existingIndexHierarchy
, or creating anIndexHierarchy
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 anIndexHierarchy
. 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
- 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
- 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 isTrue
.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
- 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
- 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 bycount
. s
- Return a
- SeriesHE.transpose() static_frame.core.series.Series
Transpose. For a 1D immutable container, this returns a reference to self.
- Returns
- 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: Constructor | Exporter | Attribute | Method | Dictionary-Like | Display | Assignment | Selector | Iterator | Operator Binary | Operator Unary | Accessor Datetime | Accessor String | Accessor Fill Value | Accessor Regular Expression
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
- 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: Constructor | Exporter | Attribute | Method | Dictionary-Like | Display | Assignment | Selector | Iterator | Operator Binary | Operator Unary | Accessor Datetime | Accessor String | Accessor Fill Value | Accessor Regular Expression
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, thestatic_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, thestatic_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, thestatic_frame.DisplayActive
will be used.
SeriesHE: Constructor | Exporter | Attribute | Method | Dictionary-Like | Display | Assignment | Selector | Iterator | Operator Binary | Operator Unary | Accessor Datetime | Accessor String | Accessor Fill Value | Accessor Regular Expression
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: Constructor | Exporter | Attribute | Method | Dictionary-Like | Display | Assignment | Selector | Iterator | Operator Binary | Operator Unary | Accessor Datetime | Accessor String | Accessor Fill Value | Accessor Regular Expression
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: Constructor | Exporter | Attribute | Method | Dictionary-Like | Display | Assignment | Selector | Iterator | Operator Binary | Operator Unary | Accessor Datetime | Accessor String | Accessor Fill Value | Accessor Regular Expression
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)
- SeriesHE.iter_group(*, axis).apply(func, *, dtype, name, index_constructor)
-
- 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)
-
- 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)
-
- 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)
-
- 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)
-
- 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)
-
- 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)
-
- 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)
-
- 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)
-
- 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)
-
- 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)
-
- 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)
-
- 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)
-
- 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_array(*, axis)
- SeriesHE.iter_group_array(*, axis).apply(func, *, dtype, name, index_constructor)
-
- 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_array(*, axis).apply_iter(func)
-
- 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_array(*, axis).apply_iter_items(func)
-
- 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_array(*, axis).apply_pool(func, *, dtype, name, index_constructor, max_workers, chunksize, use_threads)
-
- 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_array(*, axis).map_all(mapping, *, dtype, name, index_constructor)
-
- 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_array(*, axis).map_all_iter(mapping)
-
- 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_array(*, axis).map_all_iter_items(mapping)
-
- 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_array(*, axis).map_any(mapping, *, dtype, name, index_constructor)
-
- 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_array(*, axis).map_any_iter(mapping)
-
- 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_array(*, axis).map_any_iter_items(mapping)
-
- 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_array(*, axis).map_fill(mapping, *, fill_value, dtype, name, index_constructor)
-
- 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_array(*, axis).map_fill_iter(mapping, *, fill_value)
-
- 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_array(*, axis).map_fill_iter_items(mapping, *, fill_value)
-
- 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_array_items(*, axis)
- iter_group_array_items
- SeriesHE.iter_group_array_items(*, axis).apply(func, *, dtype, name, index_constructor)
- iter_group_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_group_array_items(*, axis).apply_iter(func)
- iter_group_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_group_array_items(*, axis).apply_iter_items(func)
- iter_group_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_group_array_items(*, axis).apply_pool(func, *, dtype, name, index_constructor, max_workers, chunksize, use_threads)
- iter_group_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_group_array_items(*, axis).map_all(mapping, *, dtype, name, index_constructor)
- iter_group_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_group_array_items(*, axis).map_all_iter(mapping)
- iter_group_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_group_array_items(*, axis).map_all_iter_items(mapping)
- iter_group_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_group_array_items(*, axis).map_any(mapping, *, dtype, name, index_constructor)
- iter_group_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_group_array_items(*, axis).map_any_iter(mapping)
- iter_group_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_group_array_items(*, axis).map_any_iter_items(mapping)
- iter_group_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_group_array_items(*, axis).map_fill(mapping, *, fill_value, dtype, name, index_constructor)
- iter_group_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_group_array_items(*, axis).map_fill_iter(mapping, *, fill_value)
- iter_group_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_group_array_items(*, axis).map_fill_iter_items(mapping, *, fill_value)
- iter_group_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_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_array(depth_level)
- iter_group_labels_array
- SeriesHE.iter_group_labels_array(depth_level).apply(func, *, dtype, name, index_constructor)
- iter_group_labels_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_group_labels_array(depth_level).apply_iter(func)
- iter_group_labels_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_group_labels_array(depth_level).apply_iter_items(func)
- iter_group_labels_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_group_labels_array(depth_level).apply_pool(func, *, dtype, name, index_constructor, max_workers, chunksize, use_threads)
- iter_group_labels_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_group_labels_array(depth_level).map_all(mapping, *, dtype, name, index_constructor)
- iter_group_labels_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_group_labels_array(depth_level).map_all_iter(mapping)
- iter_group_labels_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_group_labels_array(depth_level).map_all_iter_items(mapping)
- iter_group_labels_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_group_labels_array(depth_level).map_any(mapping, *, dtype, name, index_constructor)
- iter_group_labels_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_group_labels_array(depth_level).map_any_iter(mapping)
- iter_group_labels_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_group_labels_array(depth_level).map_any_iter_items(mapping)
- iter_group_labels_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_group_labels_array(depth_level).map_fill(mapping, *, fill_value, dtype, name, index_constructor)
- iter_group_labels_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_group_labels_array(depth_level).map_fill_iter(mapping, *, fill_value)
- iter_group_labels_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_group_labels_array(depth_level).map_fill_iter_items(mapping, *, fill_value)
- iter_group_labels_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_group_labels_array_items(depth_level)
- iter_group_labels_array_items
- SeriesHE.iter_group_labels_array_items(depth_level).apply(func, *, dtype, name, index_constructor)
- iter_group_labels_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_group_labels_array_items(depth_level).apply_iter(func)
- iter_group_labels_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_group_labels_array_items(depth_level).apply_iter_items(func)
- iter_group_labels_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_group_labels_array_items(depth_level).apply_pool(func, *, dtype, name, index_constructor, max_workers, chunksize, use_threads)
- iter_group_labels_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_group_labels_array_items(depth_level).map_all(mapping, *, dtype, name, index_constructor)
- iter_group_labels_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_group_labels_array_items(depth_level).map_all_iter(mapping)
- iter_group_labels_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_group_labels_array_items(depth_level).map_all_iter_items(mapping)
- iter_group_labels_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_group_labels_array_items(depth_level).map_any(mapping, *, dtype, name, index_constructor)
- iter_group_labels_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_group_labels_array_items(depth_level).map_any_iter(mapping)
- iter_group_labels_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_group_labels_array_items(depth_level).map_any_iter_items(mapping)
- iter_group_labels_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_group_labels_array_items(depth_level).map_fill(mapping, *, fill_value, dtype, name, index_constructor)
- iter_group_labels_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_group_labels_array_items(depth_level).map_fill_iter(mapping, *, fill_value)
- iter_group_labels_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_group_labels_array_items(depth_level).map_fill_iter_items(mapping, *, fill_value)
- iter_group_labels_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_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) st