Ë
|
nñúhv ã ó, d Z ddlmZ ddlmZmZmZmZ ddlZddl m
|
Z
|
m Z ddl Z ddl mZ ddlmZmZmZmZmZmZmZ ddlZddlZddlmZ dd l m Z dd
|
l m Z m Z dd l!m"Z" ddl#m$c m%Z& dd l'm(Z( dd l)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6 ddl7m8Z9 ddl:m;Z;m<Z< ddl=m>Z>m?Z?m@Z@mAZA ddlBmCZC ddlDmEZEmFZF ddlGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZS ddlTmUZUmVZVmWZW ddlXmYZYmZZZ ddl[m\Z\ ddl]m^Z^ ddl_m`Z`maZambZbmcZcmdZdmeZemfZf ddlgmhZh ddlimjZjmkZk ddllmmZmmnZn ddlompc mqZr dd lsmtZt dd lumvZv dd lwmxZxmyZymzZz dd l{m|Z| dd l}m~Z~mZ dd!lmZmZmZmZm
Z
dd"lmZ dd#lmZ dd$lmZ dd%lmZmZ erdd&lmZ dd'lmZ dd(lmZmZmZ d)Zd*d+d,d-Zd.Zd/Zd0Zd1Zd2Zd3Ze G d4 d5em« « Zeeee eegef eeegef eeef f Z G d6 d7emene1 e~« Z¡ ed8ev¬9« Z¢ G d: d;e¡e1 « Z£ eAe£« d? d@d<« Z¤dAd=Z¥d>Z¦y)Ba
|
Provide the groupby split-apply-combine paradigm. Define the GroupBy
|
class providing the base-class of operations.
|
|
The SeriesGroupBy and DataFrameGroupBy sub-class
|
(defined in pandas.core.groupby.generic)
|
expose these user-facing objects to provide specific functionality.
|
é )Ú annotations)ÚHashableÚIteratorÚMappingÚSequenceN)ÚpartialÚwraps)Údedent)Ú TYPE_CHECKINGÚCallableÚLiteralÚTypeVarÚUnionÚcastÚfinal)Úusing_string_dtype)Úoption_context)Ú TimestampÚlib)Úrank_1d)ÚNA) Ú AnyArrayLikeÚ ArrayLikeÚAxisÚAxisIntÚDtypeObjÚ FillnaOptionsÚ
|
IndexLabelÚNDFrameTÚPositionalIndexerÚ RandomStateÚScalarÚTÚnpt)Úfunction)ÚAbstractMethodErrorÚ DataError)ÚAppenderÚ SubstitutionÚcache_readonlyÚdoc)Úfind_stack_level)Úcoerce_indexer_dtypeÚensure_dtype_can_hold_na) Ú is_bool_dtypeÚis_float_dtypeÚ is_hashableÚ
|
is_integerÚis_integer_dtypeÚ is_list_likeÚis_numeric_dtypeÚis_object_dtypeÚ is_scalarÚis_string_dtypeÚneeds_i8_conversionÚ pandas_dtype)ÚisnaÚna_value_for_dtypeÚnotna)Ú
|
algorithmsÚsample)Úexecutor)Úwarn_alias_replacement)ÚArrowExtensionArrayÚBaseMaskedArrayÚ CategoricalÚExtensionArrayÚ FloatingArrayÚ IntegerArrayÚ SparseArray)Ú StringDtype)ÚArrowStringArrayÚ ArrowStringArrayNumpySemantics)Ú PandasObjectÚSelectionMixin)Ú DataFrame)ÚNDFrame)ÚbaseÚnumba_Úops)Ú get_grouper)ÚGroupByIndexingMixinÚGroupByNthSelector)ÚCategoricalIndexÚIndexÚ
|
MultiIndexÚ
|
RangeIndexÚ default_index)Úensure_block_shape)ÚSeries)Úget_group_index_sorter)Úget_jit_argumentsÚmaybe_use_numba)ÚAny)Ú Resampler)ÚExpandingGroupbyÚ ExponentialMovingWindowGroupbyÚRollingGroupbyzÍ
|
See Also
|
--------
|
Series.%(name)s : Apply a function %(name)s to a Series.
|
DataFrame.%(name)s : Apply a function %(name)s
|
to each row or column of a DataFrame.
|
al
|
Apply function ``func`` group-wise and combine the results together.
|
|
The function passed to ``apply`` must take a {input} as its first
|
argument and return a DataFrame, Series or scalar. ``apply`` will
|
then take care of combining the results back together into a single
|
dataframe or series. ``apply`` is therefore a highly flexible
|
grouping method.
|
|
While ``apply`` is a very flexible method, its downside is that
|
using it can be quite a bit slower than using more specific methods
|
like ``agg`` or ``transform``. Pandas offers a wide range of method that will
|
be much faster than using ``apply`` for their specific purposes, so try to
|
use them before reaching for ``apply``.
|
|
Parameters
|
----------
|
func : callable
|
A callable that takes a {input} as its first argument, and
|
returns a dataframe, a series or a scalar. In addition the
|
callable may take positional and keyword arguments.
|
include_groups : bool, default True
|
When True, will attempt to apply ``func`` to the groupings in
|
the case that they are columns of the DataFrame. If this raises a
|
TypeError, the result will be computed with the groupings excluded.
|
When False, the groupings will be excluded when applying ``func``.
|
|
.. versionadded:: 2.2.0
|
|
.. deprecated:: 2.2.0
|
|
Setting include_groups to True is deprecated. Only the value
|
False will be allowed in a future version of pandas.
|
|
args, kwargs : tuple and dict
|
Optional positional and keyword arguments to pass to ``func``.
|
|
Returns
|
-------
|
Series or DataFrame
|
|
See Also
|
--------
|
pipe : Apply function to the full GroupBy object instead of to each
|
group.
|
aggregate : Apply aggregate function to the GroupBy object.
|
transform : Apply function column-by-column to the GroupBy object.
|
Series.apply : Apply a function to a Series.
|
DataFrame.apply : Apply a function to each row or column of a DataFrame.
|
|
Notes
|
-----
|
|
.. versionchanged:: 1.3.0
|
|
The resulting dtype will reflect the return value of the passed ``func``,
|
see the examples below.
|
|
Functions that mutate the passed object can produce unexpected
|
behavior or errors and are not supported. See :ref:`gotchas.udf-mutation`
|
for more details.
|
|
Examples
|
--------
|
{examples}
|
a?
|
>>> df = pd.DataFrame({'A': 'a a b'.split(),
|
... 'B': [1, 2, 3],
|
... 'C': [4, 6, 5]})
|
>>> g1 = df.groupby('A', group_keys=False)
|
>>> g2 = df.groupby('A', group_keys=True)
|
|
Notice that ``g1`` and ``g2`` have two groups, ``a`` and ``b``, and only
|
differ in their ``group_keys`` argument. Calling `apply` in various ways,
|
we can get different grouping results:
|
|
Example 1: below the function passed to `apply` takes a DataFrame as
|
its argument and returns a DataFrame. `apply` combines the result for
|
each group together into a new DataFrame:
|
|
>>> g1[['B', 'C']].apply(lambda x: x / x.sum())
|
B C
|
0 0.333333 0.4
|
1 0.666667 0.6
|
2 1.000000 1.0
|
|
In the above, the groups are not part of the index. We can have them included
|
by using ``g2`` where ``group_keys=True``:
|
|
>>> g2[['B', 'C']].apply(lambda x: x / x.sum())
|
B C
|
A
|
a 0 0.333333 0.4
|
1 0.666667 0.6
|
b 2 1.000000 1.0
|
|
Example 2: The function passed to `apply` takes a DataFrame as
|
its argument and returns a Series. `apply` combines the result for
|
each group together into a new DataFrame.
|
|
.. versionchanged:: 1.3.0
|
|
The resulting dtype will reflect the return value of the passed ``func``.
|
|
>>> g1[['B', 'C']].apply(lambda x: x.astype(float).max() - x.min())
|
B C
|
A
|
a 1.0 2.0
|
b 0.0 0.0
|
|
>>> g2[['B', 'C']].apply(lambda x: x.astype(float).max() - x.min())
|
B C
|
A
|
a 1.0 2.0
|
b 0.0 0.0
|
|
The ``group_keys`` argument has no effect here because the result is not
|
like-indexed (i.e. :ref:`a transform <groupby.transform>`) when compared
|
to the input.
|
|
Example 3: The function passed to `apply` takes a DataFrame as
|
its argument and returns a scalar. `apply` combines the result for
|
each group together into a Series, including setting the index as
|
appropriate:
|
|
>>> g1.apply(lambda x: x.C.max() - x.B.min(), include_groups=False)
|
A
|
a 5
|
b 2
|
dtype: int64a
|
>>> s = pd.Series([0, 1, 2], index='a a b'.split())
|
>>> g1 = s.groupby(s.index, group_keys=False)
|
>>> g2 = s.groupby(s.index, group_keys=True)
|
|
From ``s`` above we can see that ``g`` has two groups, ``a`` and ``b``.
|
Notice that ``g1`` have ``g2`` have two groups, ``a`` and ``b``, and only
|
differ in their ``group_keys`` argument. Calling `apply` in various ways,
|
we can get different grouping results:
|
|
Example 1: The function passed to `apply` takes a Series as
|
its argument and returns a Series. `apply` combines the result for
|
each group together into a new Series.
|
|
.. versionchanged:: 1.3.0
|
|
The resulting dtype will reflect the return value of the passed ``func``.
|
|
>>> g1.apply(lambda x: x * 2 if x.name == 'a' else x / 2)
|
a 0.0
|
a 2.0
|
b 1.0
|
dtype: float64
|
|
In the above, the groups are not part of the index. We can have them included
|
by using ``g2`` where ``group_keys=True``:
|
|
>>> g2.apply(lambda x: x * 2 if x.name == 'a' else x / 2)
|
a a 0.0
|
a 2.0
|
b b 1.0
|
dtype: float64
|
|
Example 2: The function passed to `apply` takes a Series as
|
its argument and returns a scalar. `apply` combines the result for
|
each group together into a Series, including setting the index as
|
appropriate:
|
|
>>> g1.apply(lambda x: x.max() - x.min())
|
a 1
|
b 0
|
dtype: int64
|
|
The ``group_keys`` argument has no effect here because the result is not
|
like-indexed (i.e. :ref:`a transform <groupby.transform>`) when compared
|
to the input.
|
|
>>> g2.apply(lambda x: x.max() - x.min())
|
a 1
|
b 0
|
dtype: int64)ÚtemplateÚdataframe_examplesÚseries_examplesa
|
Compute {fname} of group values.
|
|
Parameters
|
----------
|
numeric_only : bool, default {no}
|
Include only float, int, boolean columns.
|
|
.. versionchanged:: 2.0.0
|
|
numeric_only no longer accepts ``None``.
|
|
min_count : int, default {mc}
|
The required number of valid values to perform the operation. If fewer
|
than ``min_count`` non-NA values are present the result will be NA.
|
|
Returns
|
-------
|
Series or DataFrame
|
Computed {fname} of values within each group.
|
|
Examples
|
--------
|
{example}
|
a:
|
Compute {fname} of group values.
|
|
Parameters
|
----------
|
numeric_only : bool, default {no}
|
Include only float, int, boolean columns.
|
|
.. versionchanged:: 2.0.0
|
|
numeric_only no longer accepts ``None``.
|
|
min_count : int, default {mc}
|
The required number of valid values to perform the operation. If fewer
|
than ``min_count`` non-NA values are present the result will be NA.
|
|
engine : str, default None {e}
|
* ``'cython'`` : Runs rolling apply through C-extensions from cython.
|
* ``'numba'`` : Runs rolling apply through JIT compiled code from numba.
|
Only available when ``raw`` is set to ``True``.
|
* ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba``
|
|
engine_kwargs : dict, default None {ek}
|
* For ``'cython'`` engine, there are no accepted ``engine_kwargs``
|
* For ``'numba'`` engine, the engine can accept ``nopython``, ``nogil``
|
and ``parallel`` dictionary keys. The values must either be ``True`` or
|
``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is
|
``{{'nopython': True, 'nogil': False, 'parallel': False}}`` and will be
|
applied to both the ``func`` and the ``apply`` groupby aggregation.
|
|
Returns
|
-------
|
Series or DataFrame
|
Computed {fname} of values within each group.
|
|
Examples
|
--------
|
{example}
|
aþ
|
Apply a ``func`` with arguments to this %(klass)s object and return its result.
|
|
Use `.pipe` when you want to improve readability by chaining together
|
functions that expect Series, DataFrames, GroupBy or Resampler objects.
|
Instead of writing
|
|
>>> h = lambda x, arg2, arg3: x + 1 - arg2 * arg3
|
>>> g = lambda x, arg1: x * 5 / arg1
|
>>> f = lambda x: x ** 4
|
>>> df = pd.DataFrame([["a", 4], ["b", 5]], columns=["group", "value"])
|
>>> h(g(f(df.groupby('group')), arg1=1), arg2=2, arg3=3) # doctest: +SKIP
|
|
You can write
|
|
>>> (df.groupby('group')
|
... .pipe(f)
|
... .pipe(g, arg1=1)
|
... .pipe(h, arg2=2, arg3=3)) # doctest: +SKIP
|
|
which is much more readable.
|
|
Parameters
|
----------
|
func : callable or tuple of (callable, str)
|
Function to apply to this %(klass)s object or, alternatively,
|
a `(callable, data_keyword)` tuple where `data_keyword` is a
|
string indicating the keyword of `callable` that expects the
|
%(klass)s object.
|
args : iterable, optional
|
Positional arguments passed into `func`.
|
kwargs : dict, optional
|
A dictionary of keyword arguments passed into `func`.
|
|
Returns
|
-------
|
the return type of `func`.
|
|
See Also
|
--------
|
Series.pipe : Apply a function with arguments to a series.
|
DataFrame.pipe: Apply a function with arguments to a dataframe.
|
apply : Apply function to each group instead of to the
|
full %(klass)s object.
|
|
Notes
|
-----
|
See more `here
|
<https://pandas.pydata.org/pandas-docs/stable/user_guide/groupby.html#piping-function-calls>`_
|
|
Examples
|
--------
|
%(examples)s
|
a¯
|
Call function producing a same-indexed %(klass)s on each group.
|
|
Returns a %(klass)s having the same indexes as the original object
|
filled with the transformed values.
|
|
Parameters
|
----------
|
f : function, str
|
Function to apply to each group. See the Notes section below for requirements.
|
|
Accepted inputs are:
|
|
- String
|
- Python function
|
- Numba JIT function with ``engine='numba'`` specified.
|
|
Only passing a single function is supported with this engine.
|
If the ``'numba'`` engine is chosen, the function must be
|
a user defined function with ``values`` and ``index`` as the
|
first and second arguments respectively in the function signature.
|
Each group's index will be passed to the user defined function
|
and optionally available for use.
|
|
If a string is chosen, then it needs to be the name
|
of the groupby method you want to use.
|
*args
|
Positional arguments to pass to func.
|
engine : str, default None
|
* ``'cython'`` : Runs the function through C-extensions from cython.
|
* ``'numba'`` : Runs the function through JIT compiled code from numba.
|
* ``None`` : Defaults to ``'cython'`` or the global setting ``compute.use_numba``
|
|
engine_kwargs : dict, default None
|
* For ``'cython'`` engine, there are no accepted ``engine_kwargs``
|
* For ``'numba'`` engine, the engine can accept ``nopython``, ``nogil``
|
and ``parallel`` dictionary keys. The values must either be ``True`` or
|
``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is
|
``{'nopython': True, 'nogil': False, 'parallel': False}`` and will be
|
applied to the function
|
|
**kwargs
|
Keyword arguments to be passed into func.
|
|
Returns
|
-------
|
%(klass)s
|
|
See Also
|
--------
|
%(klass)s.groupby.apply : Apply function ``func`` group-wise and combine
|
the results together.
|
%(klass)s.groupby.aggregate : Aggregate using one or more
|
operations over the specified axis.
|
%(klass)s.transform : Call ``func`` on self producing a %(klass)s with the
|
same axis shape as self.
|
|
Notes
|
-----
|
Each group is endowed the attribute 'name' in case you need to know
|
which group you are working on.
|
|
The current implementation imposes three requirements on f:
|
|
* f must return a value that either has the same shape as the input
|
subframe or can be broadcast to the shape of the input subframe.
|
For example, if `f` returns a scalar it will be broadcast to have the
|
same shape as the input subframe.
|
* if this is a DataFrame, f must support application column-by-column
|
in the subframe. If f also supports application to the entire subframe,
|
then a fast path is used starting from the second chunk.
|
* f must not mutate groups. Mutation is not supported and may
|
produce unexpected results. See :ref:`gotchas.udf-mutation` for more details.
|
|
When using ``engine='numba'``, there will be no "fall back" behavior internally.
|
The group data and group index will be passed as numpy arrays to the JITed
|
user defined function, and no alternative execution attempts will be tried.
|
|
.. versionchanged:: 1.3.0
|
|
The resulting dtype will reflect the return value of the passed ``func``,
|
see the examples below.
|
|
.. versionchanged:: 2.0.0
|
|
When using ``.transform`` on a grouped DataFrame and the transformation function
|
returns a DataFrame, pandas now aligns the result's index
|
with the input's index. You can call ``.to_numpy()`` on the
|
result of the transformation function to avoid alignment.
|
|
Examples
|
--------
|
%(example)saP
|
Aggregate using one or more operations over the specified axis.
|
|
Parameters
|
----------
|
func : function, str, list, dict or None
|
Function to use for aggregating the data. If a function, must either
|
work when passed a {klass} or when passed to {klass}.apply.
|
|
Accepted combinations are:
|
|
- function
|
- string function name
|
- list of functions and/or function names, e.g. ``[np.sum, 'mean']``
|
- None, in which case ``**kwargs`` are used with Named Aggregation. Here the
|
output has one column for each element in ``**kwargs``. The name of the
|
column is keyword, whereas the value determines the aggregation used to compute
|
the values in the column.
|
|
Can also accept a Numba JIT function with
|
``engine='numba'`` specified. Only passing a single function is supported
|
with this engine.
|
|
If the ``'numba'`` engine is chosen, the function must be
|
a user defined function with ``values`` and ``index`` as the
|
first and second arguments respectively in the function signature.
|
Each group's index will be passed to the user defined function
|
and optionally available for use.
|
|
.. deprecated:: 2.1.0
|
|
Passing a dictionary is deprecated and will raise in a future version
|
of pandas. Pass a list of aggregations instead.
|
*args
|
Positional arguments to pass to func.
|
engine : str, default None
|
* ``'cython'`` : Runs the function through C-extensions from cython.
|
* ``'numba'`` : Runs the function through JIT compiled code from numba.
|
* ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba``
|
|
engine_kwargs : dict, default None
|
* For ``'cython'`` engine, there are no accepted ``engine_kwargs``
|
* For ``'numba'`` engine, the engine can accept ``nopython``, ``nogil``
|
and ``parallel`` dictionary keys. The values must either be ``True`` or
|
``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is
|
``{{'nopython': True, 'nogil': False, 'parallel': False}}`` and will be
|
applied to the function
|
|
**kwargs
|
* If ``func`` is None, ``**kwargs`` are used to define the output names and
|
aggregations via Named Aggregation. See ``func`` entry.
|
* Otherwise, keyword arguments to be passed into func.
|
|
Returns
|
-------
|
{klass}
|
|
See Also
|
--------
|
{klass}.groupby.apply : Apply function func group-wise
|
and combine the results together.
|
{klass}.groupby.transform : Transforms the Series on each group
|
based on the given function.
|
{klass}.aggregate : Aggregate using one or more
|
operations over the specified axis.
|
|
Notes
|
-----
|
When using ``engine='numba'``, there will be no "fall back" behavior internally.
|
The group data and group index will be passed as numpy arrays to the JITed
|
user defined function, and no alternative execution attempts will be tried.
|
|
Functions that mutate the passed object can produce unexpected
|
behavior or errors and are not supported. See :ref:`gotchas.udf-mutation`
|
for more details.
|
|
.. versionchanged:: 1.3.0
|
|
The resulting dtype will reflect the return value of the passed ``func``,
|
see the examples below.
|
{examples}a÷
|
Aggregate using one or more operations over the specified axis.
|
|
Parameters
|
----------
|
func : function, str, list, dict or None
|
Function to use for aggregating the data. If a function, must either
|
work when passed a {klass} or when passed to {klass}.apply.
|
|
Accepted combinations are:
|
|
- function
|
- string function name
|
- list of functions and/or function names, e.g. ``[np.sum, 'mean']``
|
- dict of axis labels -> functions, function names or list of such.
|
- None, in which case ``**kwargs`` are used with Named Aggregation. Here the
|
output has one column for each element in ``**kwargs``. The name of the
|
column is keyword, whereas the value determines the aggregation used to compute
|
the values in the column.
|
|
Can also accept a Numba JIT function with
|
``engine='numba'`` specified. Only passing a single function is supported
|
with this engine.
|
|
If the ``'numba'`` engine is chosen, the function must be
|
a user defined function with ``values`` and ``index`` as the
|
first and second arguments respectively in the function signature.
|
Each group's index will be passed to the user defined function
|
and optionally available for use.
|
|
*args
|
Positional arguments to pass to func.
|
engine : str, default None
|
* ``'cython'`` : Runs the function through C-extensions from cython.
|
* ``'numba'`` : Runs the function through JIT compiled code from numba.
|
* ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba``
|
|
engine_kwargs : dict, default None
|
* For ``'cython'`` engine, there are no accepted ``engine_kwargs``
|
* For ``'numba'`` engine, the engine can accept ``nopython``, ``nogil``
|
and ``parallel`` dictionary keys. The values must either be ``True`` or
|
``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is
|
``{{'nopython': True, 'nogil': False, 'parallel': False}}`` and will be
|
applied to the function
|
|
**kwargs
|
* If ``func`` is None, ``**kwargs`` are used to define the output names and
|
aggregations via Named Aggregation. See ``func`` entry.
|
* Otherwise, keyword arguments to be passed into func.
|
|
Returns
|
-------
|
{klass}
|
|
See Also
|
--------
|
{klass}.groupby.apply : Apply function func group-wise
|
and combine the results together.
|
{klass}.groupby.transform : Transforms the Series on each group
|
based on the given function.
|
{klass}.aggregate : Aggregate using one or more
|
operations over the specified axis.
|
|
Notes
|
-----
|
When using ``engine='numba'``, there will be no "fall back" behavior internally.
|
The group data and group index will be passed as numpy arrays to the JITed
|
user defined function, and no alternative execution attempts will be tried.
|
|
Functions that mutate the passed object can produce unexpected
|
behavior or errors and are not supported. See :ref:`gotchas.udf-mutation`
|
for more details.
|
|
.. versionchanged:: 1.3.0
|
|
The resulting dtype will reflect the return value of the passed ``func``,
|
see the examples below.
|
{examples}c ó& e Zd ZdZddZd ZddZy)Ú GroupByPlotzE
|
Class implementing the .plot attribute for groupby objects.
|
c ó || _ y ©N)Ú_groupby)ÚselfÚgroupbys úNH:\Change_password\venv_build\Lib\site-packages\pandas/core/groupby/groupby.pyÚ__init__zGroupByPlot.__init__á s Ø ó c ó fd}d|_ | j j || j j « S )Nc ó( | j i ¤S rk )Úplot)rm ÚargsÚkwargss ro Úfz GroupByPlot.__call__.<locals>.få s ø Ø 499dÐ- fÑ-Ð -rq rt )Ú__name__rl Ú_python_apply_generalÚ _selected_obj)rm ru rv rw s `` ro Ú__call__zGroupByPlot.__call__ä s2 ù õ .ð
|
Ø}}×2Ñ2°1°d·m±m×6QÑ6QÓRÐRrq c ó fd}|S )Nc óv fd}j j |j j « S )Nc ó< t | j « i ¤S rk )Úgetattrrt )rm ru rv Únames ro rw z0GroupByPlot.__getattr__.<locals>.attr.<locals>.fí s ø Ø/wtyy¨$Ó/°Ð@¸Ñ@Ð@rq )rl ry rz )ru rv rw r rm s `` ro Úattrz%GroupByPlot.__getattr__.<locals>.attrì s, ú ö Að ==×6Ñ6°q¸$¿-¹-×:UÑ:UÓVÐ Vrq © )rm r r s `` ro Ú __getattr__zGroupByPlot.__getattr__ë s ù õ Wð rq N)rn ÚGroupByÚreturnÚNone©r Ústr)rx Ú
|
__module__Ú __qualname__Ú__doc__rp r{ r r rq ro ri ri Û s ñó òSôrq ri c ó¼ e Zd ZU ej h d£z Zded< ded< dZded< dZd ed
|
< d ed < ed d « Z ed d« Z
|
ee d d« « Z ee d d« « Z ee d d« « Zee d!d« « Zed « Zed « Zeed « « Zed"d« Z ed ed« ¬« ee« d#d« « Zed$d%d« Zed&d « Zy)'Ú BaseGroupBy> ÚobjÚaxisÚkeysÚsortÚlevelÚdropnaÚgrouperÚas_indexÚobservedÚ
|
exclusionsÚ
|
group_keysr r úops.BaseGrouperÚ_grouperNú_KeysArgType | Noner úIndexLabel | Noner Úboolr c ó, t | j « S rk )ÚlenÚgroups©rm s ro Ú__len__zBaseGroupBy.__len__ s ä4;;Ó Ð rq c ó, t j | « S rk )ÚobjectÚ__repr__r¡ s ro r¥ zBaseGroupBy.__repr__ s ô tÓ$Ð$rq c ó t j t | « j dt t « ¬« | j S )NzI.grouper is deprecated and will be removed in a future version of pandas.)ÚcategoryÚ
|
stacklevel)ÚwarningsÚwarnÚtyperx Ú FutureWarningr, r r¡ s ro r zBaseGroupBy.grouper s? ô ÜDz×"Ñ"Ð#ð $(ð (ä"Ü'Ó)õ
|
ð }}Ð rq c ó. | j j S )aI
|
Dict {group name -> group labels}.
|
|
Examples
|
--------
|
|
For SeriesGroupBy:
|
|
>>> lst = ['a', 'a', 'b']
|
>>> ser = pd.Series([1, 2, 3], index=lst)
|
>>> ser
|
a 1
|
a 2
|
b 3
|
dtype: int64
|
>>> ser.groupby(level=0).groups
|
{'a': ['a', 'a'], 'b': ['b']}
|
|
For DataFrameGroupBy:
|
|
>>> data = [[1, 2, 3], [1, 5, 6], [7, 8, 9]]
|
>>> df = pd.DataFrame(data, columns=["a", "b", "c"])
|
>>> df
|
a b c
|
0 1 2 3
|
1 1 5 6
|
2 7 8 9
|
>>> df.groupby(by=["a"]).groups
|
{1: [0, 1], 7: [2]}
|
|
For Resampler:
|
|
>>> ser = pd.Series([1, 2, 3, 4], index=pd.DatetimeIndex(
|
... ['2023-01-01', '2023-01-15', '2023-02-01', '2023-02-15']))
|
>>> ser
|
2023-01-01 1
|
2023-01-15 2
|
2023-02-01 3
|
2023-02-15 4
|
dtype: int64
|
>>> ser.resample('MS').groups
|
{Timestamp('2023-01-01 00:00:00'): 2, Timestamp('2023-02-01 00:00:00'): 4}
|
)r r r¡ s ro r zBaseGroupBy.groups' s ð\ }}×#Ñ#Ð#rq c ó. | j j S rk )r Úngroupsr¡ s ro r¯ zBaseGroupBy.ngroupsW s ð }}×$Ñ$Ð$rq c ó. | j j S )aæ
|
Dict {group name -> group indices}.
|
|
Examples
|
--------
|
|
For SeriesGroupBy:
|
|
>>> lst = ['a', 'a', 'b']
|
>>> ser = pd.Series([1, 2, 3], index=lst)
|
>>> ser
|
a 1
|
a 2
|
b 3
|
dtype: int64
|
>>> ser.groupby(level=0).indices
|
{'a': array([0, 1]), 'b': array([2])}
|
|
For DataFrameGroupBy:
|
|
>>> data = [[1, 2, 3], [1, 5, 6], [7, 8, 9]]
|
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
|
... index=["owl", "toucan", "eagle"])
|
>>> df
|
a b c
|
owl 1 2 3
|
toucan 1 5 6
|
eagle 7 8 9
|
>>> df.groupby(by=["a"]).indices
|
{1: array([0, 1]), 7: array([2])}
|
|
For Resampler:
|
|
>>> ser = pd.Series([1, 2, 3, 4], index=pd.DatetimeIndex(
|
... ['2023-01-01', '2023-01-15', '2023-02-01', '2023-02-15']))
|
>>> ser
|
2023-01-01 1
|
2023-01-15 2
|
2023-02-01 3
|
2023-02-15 4
|
dtype: int64
|
>>> ser.resample('MS').indices
|
defaultdict(<class 'list'>, {Timestamp('2023-01-01 00:00:00'): [0, 1],
|
Timestamp('2023-02-01 00:00:00'): [2, 3]})
|
)r Úindicesr¡ s ro r± zBaseGroupBy.indices\ s ð` }}×$Ñ$Ð$rq c ó
|
d }t |« dk( rg S t | j « dkD r t t | j « « }nd}|d }t |t
|
« rtt |t
|
« s d}t |« t |« t |« k( s |D cg c] }| j | c}S |D cg c]
|
} ||« c}
|
|
fd|D « }n ||« fd|D « }|D cg c] }| j j |g « c}S c c}w # t $ r}d}t |« |d}~ww xY wc c}w c c}w )zd
|
Safe get multiple indices, translate keys for
|
datelike to underlying repr.
|
c ó| t | t j « rd S t | t j « rd S d S )Nc ó t | « S rk )r ©Úkeys ro ú<lambda>zABaseGroupBy._get_indices.<locals>.get_converter.<locals>.<lambda> s
|
¤9¨S£> rq c ó, t | « j S rk )r Úasm8rµ s ro r· zABaseGroupBy._get_indices.<locals>.get_converter.<locals>.<lambda> s ¤9¨S£>×#6Ñ#6 rq c ó | S rk r rµ s ro r· zABaseGroupBy._get_indices.<locals>.get_converter.<locals>.<lambda> s 3 rq )Ú
|
isinstanceÚdatetimeÚnpÚ
|
datetime64)Úss ro Ú get_converterz/BaseGroupBy._get_indices.<locals>.get_converter s4 ô !X× .Ñ .Ô/Ù1Ð1ÜAr}}Ô-Ù6Ð6á&Ð&rq r Nz<must supply a tuple to get_group with multiple grouping keyszHmust supply a same-length tuple to get_group with multiple grouping keysc 3 óV K | ] }t d t |« D « « " yw)c 3 ó2 K | ] \ }} ||« y wrk r )Ú.0rw Úns ro ú <genexpr>z5BaseGroupBy._get_indices.<locals>.<genexpr>.<genexpr>¹ s è ø ÒB¡D A q1Q4ÑBùs N)ÚtupleÚzip)rà r Ú
|
converterss ro rÅ z+BaseGroupBy._get_indices.<locals>.<genexpr>¹ s# øè ø ÒUÀtUÑB¬C°
|
¸DÓ,AÔB×BÑUùs &)c 3 ó. K | ] } |« y wrk r )rà r Ú converters ro rÅ z+BaseGroupBy._get_indices.<locals>.<genexpr>½ s øè ø Ò7¨Yt_Ñ7ùs ) r r± ÚnextÚiterr» rÆ Ú
|
ValueErrorÚKeyErrorÚget) rm ÚnamesrÀ Ú index_sampleÚ name_sampleÚmsgr Úerrr¿ rÊ rÈ s @@ro Ú _get_indiceszBaseGroupBy._get_indices s2 ù ò 'ô u:?ØIä t||Ó qÒ Ü ¤ T§\¡\Ó 2Ó3Là LàAh Ü l¤EÔ *Ü k¬5Ô1ØTÜ oÐ%Ü{Ó#¤s¨<Ó'8Ò8ð 3à;@ÖA°4DLL¨Ó .ÒAÐAð 5AÖA¨q-¨Õ*ÒAJÛUÈuÔUEñ & lÓ3IÛ7°Ô7Eà7<Ö=¨t × Ñ rÕ*Ò=Ð=ùò! BøÜ ò 3ð6ð ô % S/¨sÐ2ûð 3üò Bùò >s6 ÂD Â DÂ3D Â:D9Ã/#D>ÄD Ä D6Ä#D1Ä1D6c ó, | j |g« d S )zQ
|
Safe get index, translate keys for datelike to underlying repr.
|
r )rÕ )rm r s ro Ú
|
_get_indexzBaseGroupBy._get_indexÁ s ð
|
× Ñ $ Ó(¨Ñ+Ð+rq c óò t | j t « r | j S | j :t | j « r| j | j S | j
|
S | j S rk )r» r r\ Ú
|
_selectionr1 Ú_obj_with_exclusionsr¡ s ro rz zBaseGroupBy._selected_objÈ s] ô dhh¤Ô 'Ø88Oà ??Ð &Ü4??Ô+ð xx §¡Ñ0Ð0ð
|
×,Ñ,Ð ,àxxrq c ó6 | j j « S rk )r Ú_dir_additionsr¡ s ro rÜ zBaseGroupBy._dir_additionsÝ s àxx×&Ñ&Ó(Ð(rq r a >>> df = pd.DataFrame({'A': 'a b a b'.split(), 'B': [1, 2, 3, 4]})
|
>>> df
|
A B
|
0 a 1
|
1 b 2
|
2 a 3
|
3 b 4
|
|
To get the difference between each groups maximum and minimum value in one
|
pass, you can do
|
|
>>> df.groupby('A').pipe(lambda x: x.max() - x.min())
|
B
|
A
|
a 2
|
b 2)ÚklassÚexamplesc ó6 t j | |g|¢i |¤S rk )ÚcomÚpipe)rm Úfuncru rv s ro rá zBaseGroupBy.pipeá s ô: xxdÐ4 TÒ4¨VÑ4Ð4rq c ó | j }| j }t |« rt |« dk( st |« rft |« dk( rXt |t
|
« rt |« dk( r|d }n4t |t
|
« s$t j dt t « ¬« | j |« }t |« s t |« |7| j dk( r|n t d« |f}| j j | S t j dt t « ¬« |j! || j ¬« S )aA
|
Construct DataFrame from group with provided name.
|
|
Parameters
|
----------
|
name : object
|
The name of the group to get as a DataFrame.
|
obj : DataFrame, default None
|
The DataFrame to take the DataFrame out of. If
|
it is None, the object groupby was called on will
|
be used.
|
|
.. deprecated:: 2.1.0
|
The obj is deprecated and will be removed in a future version.
|
Do ``df.iloc[gb.indices.get(name)]``
|
instead of ``gb.get_group(name, obj=df)``.
|
|
Returns
|
-------
|
same type as obj
|
|
Examples
|
--------
|
|
For SeriesGroupBy:
|
|
>>> lst = ['a', 'a', 'b']
|
>>> ser = pd.Series([1, 2, 3], index=lst)
|
>>> ser
|
a 1
|
a 2
|
b 3
|
dtype: int64
|
>>> ser.groupby(level=0).get_group("a")
|
a 1
|
a 2
|
dtype: int64
|
|
For DataFrameGroupBy:
|
|
>>> data = [[1, 2, 3], [1, 5, 6], [7, 8, 9]]
|
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
|
... index=["owl", "toucan", "eagle"])
|
>>> df
|
a b c
|
owl 1 2 3
|
toucan 1 5 6
|
eagle 7 8 9
|
>>> df.groupby(by=["a"]).get_group((1,))
|
a b c
|
owl 1 2 3
|
toucan 1 5 6
|
|
For Resampler:
|
|
>>> ser = pd.Series([1, 2, 3, 4], index=pd.DatetimeIndex(
|
... ['2023-01-01', '2023-01-15', '2023-02-01', '2023-02-15']))
|
>>> ser
|
2023-01-01 1
|
2023-01-15 2
|
2023-02-01 3
|
2023-02-15 4
|
dtype: int64
|
>>> ser.resample('MS').get_group('2023-01-01')
|
2023-01-01 1
|
2023-01-15 2
|
dtype: int64
|
é r zµWhen grouping with a length-1 list-like, you will need to pass a length-1 tuple to get_group in a future version of pandas. Pass `(name,)` instead of `name` to silence this warning.©r¨ Nzobj is deprecated and will be removed in a future version. Do ``df.iloc[gb.indices.get(name)]`` instead of ``gb.get_group(name, obj=df)``.©r )r r r4 r r» rÆ r© rª r¬ r, r× rÎ r Úslicerz ÚilocÚ_take_with_is_copy)rm r r r r ÚindsÚindexers ro Ú get_groupzBaseGroupBy.get_group s ðL yyØ
|
|
ä Ô ¤C¨£J°!¢OÜ Ô ¤3 t£9°¢>ô $¤Ô&¬3¨t«9¸ª>àAwÜ ¤eÔ,Ü ð$ô "Ü /Ó 1õ ð tÓ$Ü4yÜ4.Ð à ;Ø "ii¨1nd´5¸³;ÀÐ2EGØ×%Ñ%×*Ñ*¨7Ñ3Ð 3ä MMð=ô Ü+Ó-õ ð ×)Ñ)¨$°T·Y±YÐ)Ó?Ð ?rq c ó` | j }| j }| j j | j | j
|
¬« }t |« r2t |« dk( r$t j dt t « ¬« t |t « rt |« dk( r d |D « }|S )aB
|
Groupby iterator.
|
|
Returns
|
-------
|
Generator yielding sequence of (name, subsetted object)
|
for each group
|
|
Examples
|
--------
|
|
For SeriesGroupBy:
|
|
>>> lst = ['a', 'a', 'b']
|
>>> ser = pd.Series([1, 2, 3], index=lst)
|
>>> ser
|
a 1
|
a 2
|
b 3
|
dtype: int64
|
>>> for x, y in ser.groupby(level=0):
|
... print(f'{x}\n{y}\n')
|
a
|
a 1
|
a 2
|
dtype: int64
|
b
|
b 3
|
dtype: int64
|
|
For DataFrameGroupBy:
|
|
>>> data = [[1, 2, 3], [1, 5, 6], [7, 8, 9]]
|
>>> df = pd.DataFrame(data, columns=["a", "b", "c"])
|
>>> df
|
a b c
|
0 1 2 3
|
1 1 5 6
|
2 7 8 9
|
>>> for x, y in df.groupby(by=["a"]):
|
... print(f'{x}\n{y}\n')
|
(1,)
|
a b c
|
0 1 2 3
|
1 1 5 6
|
(7,)
|
a b c
|
2 7 8 9
|
|
For Resampler:
|
|
>>> ser = pd.Series([1, 2, 3, 4], index=pd.DatetimeIndex(
|
... ['2023-01-01', '2023-01-15', '2023-02-01', '2023-02-15']))
|
>>> ser
|
2023-01-01 1
|
2023-01-15 2
|
2023-02-01 3
|
2023-02-15 4
|
dtype: int64
|
>>> for x, y in ser.resample('MS'):
|
... print(f'{x}\n{y}\n')
|
2023-01-01 00:00:00
|
2023-01-01 1
|
2023-01-15 2
|
dtype: int64
|
2023-02-01 00:00:00
|
2023-02-01 3
|
2023-02-15 4
|
dtype: int64
|
ræ rä zÏCreating a Groupby object with a length-1 list-like level parameter will yield indexes as tuples in a future version. To keep indexes as scalars, create Groupby objects with a scalar level parameter instead.rå c 3 ó, K | ] \ }}|f|f y wrk r )rà r¶ Úgroups ro rÅ z'BaseGroupBy.__iter__.<locals>.<genexpr>à s è ø Ò?©*¨#¨uvuoÑ?ùs )r r r Ú get_iteratorrz r r4 r r© rª r¬ r, r» Úlist)rm r r Úresults ro Ú__iter__zBaseGroupBy.__iter__k s ðP yyØ
|
|
Ø ×+Ñ+¨D×,>Ñ,>ÀTÇYÁYÐ+ÓOä Ô ¤3 u£:°¢?ä MMð4ô Ü+Ó-õ ô dDÔ !¤c¨$£i°1¢ná?¸Ô?FØ rq )r
Úint)r
r )r
r )r
zdict[Hashable, np.ndarray])r
z$dict[Hashable, npt.NDArray[np.intp]])r
zset[str])râ z/Callable[..., T] | tuple[Callable[..., T], str]r
r# rk ©r
úDataFrame | Series)r
z#Iterator[tuple[Hashable, NDFrameT]]) rx r r rL Ú _hidden_attrsÚ__annotations__r r r r¢ r¥ Úpropertyr r r¯ r± rÕ r× r* rz rÜ r) r
|
r( Ú_pipe_templaterá rì ró r rq ro r r þ sª
Ø ×.Ñ.ò 2ñ Mð MØ Ó Ø $DÐ
|
Ó$Ø #EÐ Ó#ØÓà
|
ò ó ð ð ò%ó ð%ð Ø ò ó ó ð ð Ø ò,$ó ó ð,$ð\ Ø ò%ó ó ð%ð Ø ò.%ó ó ð.%ð` ñ0>ó ð0>ðd ñ,ó ð,ð Øñó ó ðð& ò)ó ð)ñ ØÙð ó
|
ôñ, nÓ ð5à=ð5ð
|
|
ò 5ó ó-ð.5ð óh@ó ðh@ðT òXó ñXrq r ÚOutputFrameOrSeries)Úboundc ó e Zd ZU dZded< ded< edddddddddej df did « Zdjd
|
Z edkd « Z
|
edld « Z e dm dnd« Z e dod« Z edpd« Zedqd« Ze dr dsd« Z dm dtdZedud« Z dvdZeddd« Zeddd« Z eed j1 ded ¬ « « dd dwd « Ze dx dyd « Ze dzdd! d{d"« Z d|d#Z e d} d~d$« Z d dd%Z eddd&d'« Z edqd(« Z ed) « Z!eddd*« Z"ee#dd+« « Z$e e%d,¬-« e%e&¬.« ddd/« « « Z'e e%d,¬-« e%e&¬.« ddd0« « « Z(e e%d,¬-« e%e&¬.« d
d1« « « Z)e e%d,¬-« e%e&¬.« d dd2« « « Z*eddd3« Z+e e%d,¬-« e%e&¬.« d dd5« « « Z,e e%d,¬-« e%e&¬.« d dd6« « « Z-e d dd7« Z.eddd8« Z/e e%d,¬-« e%e&¬.« dd9« « « Z0e e1e2d:d ddd e3d;« ¬<« d dd=« « Z4e e1e5d>d d e3d?« ¬@« dddA« « Z6e e1e2dBd d dd e3dC« ¬<« d ddD« « Z7e e1e2dEd d dd e3dF« ¬<« d ddG« « Z8e d ddH« Z9e d ddI« Z:eddJ« Z; e1e<jz « d d
dK« Z=edd ddL« Z>eddM« Z?e e%d,¬-« ee&« ddN« « « Z@e e%d,¬-« ee&« ddO« « « ZAedrddP« ZBe e%d,¬-« drddQ« « ZCe e%d,¬-« drddR« « ZDee# e%d,¬-« e%e&¬.« ddS« « « « ZE dr d dTZFe d¡ d¢dU« ZGe e%d,¬-« dd£dV« « ZHe e%d,¬-« dd£dW« « ZIe e%d,¬-« e%e&¬.« dXddYd ej f d¤dZ« « « ZJe e%d,¬-« e%e&¬.« ej f d¥d[« « « ZKe e%d,¬-« e%e&¬.« ej f d¥d\« « « ZLe e%d,¬-« e%e&¬.« ej d f d¦d]« « « ZMe e%d,¬-« e%e&¬.« ej d f d¦d^« « « ZNe e%d,¬-« d4dej ej df d§d_« « ZOe e%d,¬-« e%e&¬.« d4ej f d¨d`« « « ZPe e%d,¬-« e%e&¬.« d4ej ej dej f d©da« « « ZQe e%d,¬-« e%e&¬.« dªd«db« « « ZRe e%d,¬-« e%e&¬.« dªd«dc« « « ZSed¬dd« ZTeeUj¬ ddf dde« ZWe d® d¯df« ZXd ej dd f d°dgZYd±dhZZy)²r a
|
Class for grouping and aggregating relational data.
|
|
See aggregate, transform, and apply functions on this object.
|
|
It's easiest to use obj.groupby(...) to use GroupBy, but you can also do:
|
|
::
|
|
grouped = groupby(obj, ...)
|
|
Parameters
|
----------
|
obj : pandas object
|
axis : int, default 0
|
level : int, default None
|
Level of MultiIndex
|
groupings : list of Grouping objects
|
Most users should ignore this
|
exclusions : array-like, optional
|
List of columns to exclude
|
name : str
|
Most users should ignore this
|
|
Returns
|
-------
|
**Attributes**
|
groups : dict
|
{group name -> group labels}
|
len(grouped) : int
|
Number of groups
|
|
Notes
|
-----
|
After grouping, see aggregate, apply, and transform functions. Here are
|
some other brief notes about usage. When grouping by multiple groups, the
|
result index will be a MultiIndex (hierarchical) by default.
|
|
Iteration produces (key, group) tuples, i.e. chunking the data by group. So
|
you can write code like:
|
|
::
|
|
grouped = obj.groupby(keys, axis=axis)
|
for key, group in grouped:
|
# do something with the data
|
|
Function calls on GroupBy, if not specially implemented, "dispatch" to the
|
grouped data. So if you group a DataFrame and wish to invoke the std()
|
method on each group, you can simply do:
|
|
::
|
|
df.groupby(mapper).std()
|
|
rather than
|
|
::
|
|
df.groupby(mapper).aggregate(np.std)
|
|
You can pass arguments to these "wrapped" functions, too.
|
|
See the online documentation for full exposition on these topics and much
|
more
|
r r r r Nr Tc óx || _ t |t « sJ t |« « || _ |s|dk7 r t d« || _ || _ | | _ |
|
| _ | | _
|
|4t ||||| | t j u rdn| | j ¬« \ }}}| t j u rBt d |j D « « r$t! j" dt$ t' « ¬« d} | | _ || _ |j- |« | _ || _ |rt3 |« | _ y t3 « | _ y )Nr z$as_index=False only valid for axis=0F)r r r r r c 3 ó4 K | ] }|j y wrk ©Ú_passed_categorical©rà Úpings ro rÅ z#GroupBy.__init__.<locals>.<genexpr>> s è ø ÒJ°4×+Õ+ÑJùó zÜThe default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.rå )rÙ r» rO r« r rÍ r r r r r rS r Ú
|
no_defaultÚanyÚ groupingsr© rª r¬ r, r r Ú_get_axis_numberr r Ú frozensetr ) rm r r r r r r Ú selectionr r r r r s ro rp zGroupBy.__init__ s" ð $ä#wÔ'Ð2¬¨c«Ó2Ð'à
|
áØqyÜ Ð!GÓHÐHà Ø Ø Ø$Ø à ?Ü'2ØØØØØØ"*¬c¯n©nÑ"<À(Ø{{ô(Ñ $GZ ð s~~Ñ %ÜÑJ¸×8IÑ8IÔJÔJÜ ð8ô "Ü /Ó 1õ ð HØ àØ×(Ñ(¨Ó. Ø Ù3=) JÓ/Ä9Ã;rq c óº || j v rt j | |« S || j v r| | S t dt | « j d| d« )Nú'z' object has no attribute ')Ú_internal_names_setr¤ Ú__getattribute__r ÚAttributeErrorr« rx )rm r s ro r zGroupBy.__getattr__O sd Ø 4×+Ñ+Ñ +Ü×*Ñ*¨4°Ó6Ð 6Ø 488Ñ Ø:Ð ä ØT
|
×#Ñ#Ð$Ð$?À¸vÀQÐ Gó
|
ð
|
rq c ó |dk( r>t j t | « j d| dt t « ¬« y t j dt | « j d| dt t « ¬« y )Nrä ú.zo with axis=1 is deprecated and will be removed in a future version. Operate on the un-grouped DataFrame insteadrå zThe 'axis' keyword in z\ is deprecated and will be removed in a future version. Call without passing 'axis' instead.)r© rª r« rx r¬ r, )rm r r s ro Ú_deprecate_axiszGroupBy._deprecate_axisY s| à 19Ü MMÜ:×&Ñ&Ð' q¨¨ð /$ð $ô Ü+Ó-ö ô MMØ(¬¨d«×)<Ñ)<Ð(=¸Q¸t¸fð E7ð 7ô Ü+Ó-ö rq c ó
|
t t | j « |« t j « }dv rFd t
|
j ur1| j j d « }| j ||« ndv r|dk( rn|dk( rdd< ndd< d|j v rBj dd« !j d« t
|
j u r| j d< fd}||_ |t j v r | j! || j" « S |t j$ v }| j! || j || ¬« }| j& j( r|r| j+ |« }|S )z<Compute the result of an operation by using GroupBy's apply.r ÚskewÚfillnaNr c ó | g¢i ¤S rk r )Úxru rw rv s ro Úcurriedz&GroupBy._op_via_apply.<locals>.curried s ø ÙQÐ(Ò( Ñ(Ð (rq )Ú is_transformÚnot_indexed_same)r r« rÚ ÚinspectÚ signaturer r r r r Ú
|
parametersrÏ r rx rP Úplotting_methodsry rz Útransformation_kernelsr Úhas_dropped_naÚ_set_result_index_ordered)
|
rm r ru rv Úsigr r r rò rw s
|
`` @ro Ú _op_via_applyzGroupBy._op_via_applyl ss ú ô D×2Ñ2Ó3°TÓ :Ü× Ñ Ó"à VÑ v¡´c·n±nÑ DØ88×,Ñ,¨V°F©^Ó<DØ × Ñ tÕ ,Ø vÑ ð v~ØØÒ!à!%và!"vð S^^Ñ #Øzz& $Ó'Ð/°6·:±:¸fÓ3EÌÏ É Ñ3WØ!%§¡vö )ð
|
Ôð 4×(Ñ(Ñ (Ø×-Ñ-¨g°t×7IÑ7IÓJÐ Jàt× :Ñ :Ð: Ø×+Ñ+Ø Ø × %Ñ %Ø%Ø!-Ð -ð ,ó
|
ð ==× 'Ò '©Lð ×3Ñ3°FÓ;FØ rq Fc ó ddl m} | j r|s| j r\| j j
|
}| j j }| j j } ||| j |||d¬« }nat t t |« « « } ||| j | ¬« }n-|s ||| j ¬« }| j j | j « }
|
| j r#| j j d } | dk7 } |
|
| }
|
|
|
j r|j" | j j% |
|
« s[t' j( |
|
j* « } |j, j/ | « \ }}|j1 || j ¬« }n3|j3 |
|
| j d¬« }n ||| j ¬« }| j4 j6 d k( r| j4 j8 }n$t; | j< « r | j< }nd }t? |t@ « r |||_ |S )
|
Nr ©ÚconcatF)r r ÚlevelsrÐ r )r r ræ éÿÿÿÿ©r Úcopyrä )!Úpandas.core.reshape.concatr& r r r Ú result_indexr' rÐ r rñ Úranger rz Ú _get_axisr Ú
|
group_infoÚhas_duplicatesÚaxesÚequalsr> Úunique1dÚ_valuesÚindexÚget_indexer_non_uniqueÚtakeÚreindexr Úndimr r1 rÙ r» r\ )rm Úvaluesr r r& r Ú group_levelsÚ group_namesrò r ÚaxÚlabelsÚmaskÚtargetrë Ú_r s ro Ú_concat_objectszGroupBy._concat_objects£ sÈ õ 6à ??¡<Ø}}à !]]× 7Ñ 7
|
Ø #}}× 3Ñ 3 Ø "mm× 1Ñ 1 á ØØ Ø#Ø'Ø%Ø ô ô E¤# f£+Ó .Ó/Ù ¨T¯Y©Y¸TÔBâ!ÙF¨¯©Ô3Fà×#Ñ#×-Ñ-¨d¯i©iÓ8BØ{{Ø ×1Ñ1°!Ñ4Ø |ØXð × Ò ¨¯©°T·Y±YÑ)?×)FÑ)FÀrÔ)Jä#×,Ñ,¨R¯Z©ZÓ8Ø #\\× @Ñ @ÀÓ H
|
Ø W°4·9±9Ó=à ¨°·±À ÓGñ F¨¯©Ô3Fà 88==AÒ Ø88==DÜ Ô )Ø??DàDä ffÔ %¨$Ð*:Ø FKà rq c óh | j j | j « }| j j r6| j j
|
s |j || j d¬« }|S t | j j « « }|j || j d¬« }|j | j ¬« }| j j
|
r/|j t t |« « | j ¬« }|j || j d¬« }|S )NFr) ræ ) r r. r r Ú is_monotonicr Úset_axisrW Ú result_ilocsÚ
|
sort_indexr8 rY r )rm rò Úobj_axisÚoriginal_positionss ro r! z!GroupBy._set_result_index_orderedç sç ð 88×%Ñ% d§i¡iÓ0à ==× %Ò %¨d¯m©m×.JÒ.Jà__ X°D·I±IÀE_ÓJFØMô # 4§=¡=×#=Ñ#=Ó#?Ó @ÐØ Ð!3¸$¿)¹)È% ÓPØ×"Ñ"¨¯ © Ð"Ó2Ø ==× 'Ò 'ð ^^¤J¬s°8«}Ó$=ÀDÇIÁI^ÓNFØ °· ± À ÓFà rq c
|
óü t |t « r|j « }|j }t t | j j « t | j j « « t | j j D cg c] }|j c}« « D ]G \ }}}||vs |r|j d||« "d}t j |t t « ¬« I |S c c}w )Nr zéA grouping was used that is not in the columns of the DataFrame and so was excluded from the result. This grouping will be included in a future version of pandas. Add the grouping as a column of the DataFrame to silence this warning.©Úmessager§ r¨ )r» r\ Úto_frameÚcolumnsrÇ Úreversedr rÐ Úget_group_levelsr Úin_axisÚinsertr© rª r¬ r, )rm rò rN Úgrpr ÚlevrQ rÓ s ro Ú_insert_inaxis_grouperz GroupBy._insert_inaxis_grouper sÕ ä ffÔ %Ø__Ó&Fð ..Ü"%Ü T]]×(Ñ(Ó )Ü T]]×3Ñ3Ó5Ó 6Ü ¨T¯]©]×-DÑ-DÖE cckkÒEÓ Fó#
|
ò Ñ D#wð 7Ò"ÙØMM ! T¨3Õ/ðYð ô MMØ #Ü!.Ü#3Ó#5öð# ð. ùò) Fs ÂC9c óì | j dk( rd|j }|j j | j j « r)| j j j « |_ |S )Nrä )r r# r5 r2 r r* )rm rò s ro Ú_maybe_transpose_resultz GroupBy._maybe_transpose_result! sO à 99>àXXFØ||×"Ñ" 4§8¡8§>¡>Ô2ð $xx~~× 2Ñ 2Ó 4 Ø rq c óL | j sJ| j |« }|j « }t t | j
|
j « « }n| j
|
j }| t ||« }||_ | j |« }| j ||¬« S )zÛ
|
Wraps the output of GroupBy aggregations into the expected result.
|
|
Parameters
|
----------
|
result : Series, DataFrame
|
|
Returns
|
-------
|
Series or DataFrame
|
©Úqs) r rU Ú _consolidaterW r- r r¯ r, Ú_insert_quantile_levelr5 rW Ú_reindex_output)rm rò rZ r5 Úress ro Ú_wrap_aggregated_outputz GroupBy._wrap_aggregated_output, s ð( }}ð ×0Ñ0°Ó8FØ×(Ñ(Ó*FÜ% § ¡ × 5Ñ 5Ó6Ó7Eð MM×.Ñ.Eà >ô +¨5°"Ó5Eà ð ×*Ñ*¨6Ó2Ø×#Ñ# C¨BÐ#Ó/Ð/rq c ó t | « rk ©r& )rm Údatar: r r s ro Ú_wrap_applied_outputz GroupBy._wrap_applied_outputV s ô " $Ó'Ð'rq c óZ | j j \ }}}| j j }| j j }|j || j
|
¬« j « }|j }t |t « rat | j j « dkD r t d« | j j d j } |j | « }|j |« j « }
|
t j ||« \ } } | | |
|
|fS )Nræ rä z_Grouping with more than 1 grouping labels and a MultiIndex is not supported with engine='numba'r )r r/ Ú _sort_idxÚ _sorted_idsr7 r Úto_numpyr5 r» rX r r ÚNotImplementedErrorr Úget_level_valuesr Úgenerate_slices) rm rb ÚidsrA r¯ Ú sorted_indexÚ
|
sorted_idsÚ sorted_dataÚ
|
index_dataÚ group_keyÚsorted_index_dataÚstartsÚendss ro Ú _numba_prepzGroupBy._numba_prepb s à --×2Ñ2QØ}}×.Ñ. Ø]]×.Ñ.
|
àii °4·9±9iÓ=×FÑFÓH àZZ
|
Ü j¤*Ô -Ü4==×*Ñ*Ó+¨aÒ/Ü)ðHóð ð ×/Ñ/°Ñ2×7Ñ7IØ#×4Ñ4°YÓ?JØ &OO¨LÓ 9× BÑ BÓ DÐä×*Ñ*¨:°wÓ? à Ø Ø Ø ð
|
ð
|
rq c ó¬ | j s t d« | j dk( r t d« | j }|j dk( r|n|j « }t j ||dfi t |« ¤}| j j \ }} } | j j }
|
|j j |f||
|
d|¤} | j j | j d< |j! | | j ¬« } |j dk( r$| j# d« } |j$ | _ | S |j& | _ | S ) zp
|
Perform groupby with a standard numerical aggregation function (e.g. mean)
|
with Numba.
|
z<as_index=False is not supported. Use .reset_index() instead.rä zaxis=1 is not supported.é T)r> r¯ )r1 rN )r rh r rÚ r9 rM r@ Úgenerate_shared_aggregatorr^ r r/ r¯ Ú_mgrÚapplyr, r1 Ú_constructor_from_mgrÚsqueezer rN ) rm râ Ú dtype_mappingÚ engine_kwargsÚaggregator_kwargsrb ÚdfÚ
|
aggregatorrk rA r¯ Úres_mgrrò s ro Ú_numba_agg_generalzGroupBy._numba_agg_general} s< ð }}Ü%ØNóð ð 99>Ü%Ð&@ÓAÐ Aà×(Ñ(ØYY !^T¨¯ © « ä ×8Ñ8Ø Ø Ø ñ
|
ô Ó.ñ
|
|
ð MM×,Ñ, QØ--×'Ñ'à "''--Ø ð
|
Ø "¨Gñ
|
Ø7Hñ
|
ð --×4Ñ4 QØ×)Ñ)¨'¸¿ ¹ Ð)ÓEà 99>Ø^^ IÓ.FØ ))FKð ð "\\FNØ rq )r} c ó8 | j }|j dk( r|n|j « }| j |« \ }}} }
|
t j
|
|« t j |fi t ||« ¤} | |
|
| ||t |j « g|¢ } | j t j | « d¬« } |j } |j dk( r d|j i}| j « } nd|j i} |j | fd| i|¤S )a(
|
Perform groupby transform routine with the numba engine.
|
|
This routine mimics the data splitting routine of the DataSplitter class
|
to generate the indices of each group in the sorted data and then passes the
|
data and indices into a Numba jitted function.
|
rv r ræ rä r rN r5 )rÚ r9 rM rt rQ Ú validate_udfÚ generate_numba_transform_funcr^ r rN r7 r½ Úargsortr5 r ÚravelÚ _constructor)rm râ r} ru rv rb r rr rs rl rn Únumba_transform_funcrò r5 Ú result_kwargss ro Ú_transform_with_numbaz GroupBy._transform_with_numbaª s ð ×(Ñ(ØYY !^T¨¯ © « à26×2BÑ2BÀ2Ó2FÑ/l KÜ×ÑDÔ!Ü %× CÑ CØ ñ
|
Ü% m°VÓ<ñ
|
Ð ñ &Ø Ø Ø Ø Ü
|
|
Oð
|
ð ò
|
ð RZZ¨ Ó 5¸AÓ>Ø
|
|
Ø 99>Ø # T§Y¡YÐ /MØ\\^Fà &¨¯ © Ð 5MØ t× Ñ ÑF¨uÐF¸ ÑFÐFrq c óp | j }|j dk( r|n|j « }| j |« \ }}} }
|
t j
|
|« t j |fi t ||« ¤} | |
|
| ||t |j « g|¢ } | j j } |j dk( r d|j i}| j « } nd|j i} |j | fd| i|¤}| j s*| j! |« }t# t |« « |_ |S )a*
|
Perform groupby aggregation routine with the numba engine.
|
|
This routine mimics the data splitting routine of the DataSplitter class
|
to generate the indices of each group in the sorted data and then passes the
|
data and indices into a Numba jitted function.
|
rv rä r rN r5 )rÚ r9 rM rt rQ r Úgenerate_numba_agg_funcr^ r rN r r, r r r r rU rZ r5 )rm râ r} ru rv rb r rr rs rl rn Únumba_agg_funcrò r5 r r^ s ro Ú_aggregate_with_numbaz GroupBy._aggregate_with_numbaÎ s' ð ×(Ñ(ØYY !^T¨¯ © « à26×2BÑ2BÀ2Ó2FÑ/l KÜ×ÑDÔ!Ü ×7Ñ7Ø ñ
|
Ü% m°VÓ<ñ
|
ñ Ø Ø Ø Ø Ü
|
|
Oð
|
ð ò
|
ð ×*Ñ*Ø 99>Ø # T§Y¡YÐ /MØ\\^Fà &¨¯ © Ð 5MØ d× Ñ ÑE¨eÐE°}ÑEØ}}Ø×-Ñ-¨cÓ2CÜ%¤c¨#£hÓ/CIØ
|
rq re Ú dataframerf )ÚinputrÞ )Úinclude_groupsc ó }t j « |k7 r t j | }t | ||« t t
|
« rNt | « r3t | « }t |« r |i ¤S srt d « |S t d d« sr,t « rt « fd« }n t d« }|s | j || j « S t dd « 5 | j || j « } t | j t" « s| j$ x| j j& | j j& k7 rKt) j* t, j/ t1 | « j2 d« t4 t7 « ¬« d d d « | S # t $ r( | j || j « cY cd d d « S w xY w# 1 sw Y S xY w) Nz"Cannot pass arguments to property z$apply func should be callable, not 'r c ó | g¢i ¤S rk r )Úgru râ rv s ro rw zGroupBy.apply.<locals>.f s ø á Ð3 DÒ3¨FÑ3Ð3rq z6func must be a callable if args or kwargs are suppliedzmode.chained_assignmentry rK ) rà Úis_builtin_funcÚ_builtin_table_aliasrA r» r Úhasattrr ÚcallablerÍ Ú TypeErrorr ry rÚ r rz r r\ rÙ Úshaper© rª Ú_apply_groupings_deprÚformatr« rx r¬ r, )
|
rm râ r ru rv Ú orig_funcÚaliasr^ rw rò s
|
` `` ro ry z GroupBy.applyö sò ú ð Ü×"Ñ" 4Ó(Ø Ò Ü×,Ñ,¨YÑ7EÜ " 4¨°EÔ :ä dCÔ ÜtTÔ"Ü d DÓ)ÜC=Ù Ð/¨Ñ/Ð/ÙVÜ$Ð'IÈ$ÈÐ%PÓQÐQØ
|
ô Ð"FÀtÀfÈAÐ NÓOÐOá VÜ~ätõ4ó ñ4ô !ØLóð ð Aá Ø×-Ñ-¨a°×1JÑ1JÓKÐ Kô Ð 5°tÓ <ñ Pð PØ ×3Ñ3°A°t×7IÑ7IÓJä" 4§8¡8¬VÔ4Ø Ð/Ø ×*Ñ*×0Ñ0°D×4MÑ4M×4SÑ4SÒSä MMÜ 5× <Ñ <Ü J× /Ñ /°ó!ô "/Ü#3Ó#5õ ÷ Pð4 øô ò Pð ×1Ñ1°!°T×5NÑ5NÓOÑO÷1 Pñ Pð Pú÷ Pð4 ús+ Ã:G4Ã<B:G Ç %G1Ç%G4Ç0G1Ç1G4Ç4G>c ó | j j ||| j « \ }}||}| j ||||« S )aÊ
|
Apply function f in python space
|
|
Parameters
|
----------
|
f : callable
|
Function to apply
|
data : Series or DataFrame
|
Data to apply f to
|
not_indexed_same: bool, optional
|
When specified, overrides the value of not_indexed_same. Apply behaves
|
differently when the result index is equal to the input index, but
|
this can be coincidental leading to value-dependent behavior.
|
is_transform : bool, default False
|
Indicator for whether the function is actually a transform
|
and should not have group keys prepended.
|
is_agg : bool, default False
|
Indicator for whether the function is an aggregation. When the
|
result is empty, we don't want to warn for this case.
|
See _GroupBy._python_agg_general.
|
|
Returns
|
-------
|
Series or DataFrame
|
data after applying f
|
)r Úapply_groupwiser rc )rm rw rb r r Úis_aggr: Úmutateds ro ry z GroupBy._python_apply_general< sP ðF --×7Ñ7¸¸4ÀÇÁÓKØ Ð #Ø &Ð à×(Ñ(Ø Ø Ø Ø ó
|
ð
|
rq r( )Únpfuncc ój | j d||||d|¤}|j | j d¬« S )N)ÚhowÚaltÚ numeric_onlyÚ min_countrn ©Úmethodr ©Ú_cython_agg_generalÚ __finalize__r )rm r¨ r© r r¤ rv rò s ro Ú _agg_generalzGroupBy._agg_generalj sM ð *×)Ñ)ð
|
ØØØ%Ø ñ
|
ð
|
ñ
|
ð ×"Ñ" 4§8¡8°IÐ"Ó>Ð>rq c óN |J |j dk( rt |d¬« }nHt |j |j ¬« }|j
|
d dk( sJ |j dd
df } | j j ||d¬« }|j }
|
|
|
t k( r|j t d¬« }n.t |
|
« r#|
|
j « } | j ||
|
¬« }t! ||¬ « S # t $ r*}d | d
|
|j d } t |« | « |d}~ww xY w) zn
|
Fallback to pure-python aggregation if _cython_operation raises
|
NotImplementedError.
|
Nrä F©r* ©Údtyper T)Úpreserve_dtypezagg function failed [how->z,dtype->ú])r9 )r9 r\ rN r# r³ r rè r Ú
|
agg_seriesÚ Exceptionr« r¤ Úastyper8 Úconstruct_array_typeÚ_from_sequencer[ ) rm r¦ r: r9 r§ Úserr Ú
|
res_valuesrÔ rÓ r³ Ústring_array_clss ro Ú_agg_py_fallbackzGroupBy._agg_py_fallback} s% ð Ð à ;;!Ò ä eÔ,Cô 688¨6¯<©<Ô8Bð 88A; !Ò#Ð #Ð#ð ''!Q$-Cð
|
*Ø ×1Ñ1°#°sÈ4Ð1ÓPJð Ø F?Ø#×*Ñ*¬6¸Ð*Ó>JÜ UÔ #à $× 9Ñ 9Ó ;Ð Ø)×8Ñ8¸È5Ð8ÓQJô " *°4Ô8Ð8øô# ò *Ø.¨s¨e°8¸C¿I¹I¸;ÀaÐHCà$s)C. cÐ )ûð *ús Á+ C1 Ã1 D$Ã:%D Ä D$c ó
|
j |¬«
|
d
|
fd }
|
j |« } j |« }dv r j |« } j |« } j
|
dk( r| j d¬« } | S )N©r¨ r c ó j j d| fj dz
|
d¤}|S # t $ r dv rt | t
|
« rndv r Y nw xY wJ j | j ¬« }|S )NÚ aggregaterä ©r r© ©r Úall)r rÅ ÚstdÚsem)r9 r§ )r Ú_cython_operationr9 rh r» rH r¾ )r: rò r§ rb r¦ rv r© rm s ro Ú
|
array_funcz/GroupBy._cython_agg_general.<locals>.array_funcº s³ ø ð Ø8 ×8Ñ8Ø ØØðð Q Ø 'ñ ð ñ ð& øô 'ò ð .Ñ(¬Z¸Ä Ô-LØØ[ CÐ+GÑ$GØùð úð ?Ð "?Ø×*Ñ*¨3°¸T¿Y¹YÈCÐ*ÓPFØMs /4 ´%A ÁA ©ÚidxminÚidxmaxrä Fr± ©r: r r
r )Ú_get_data_to_aggregateÚgrouped_reduceÚ_wrap_agged_managerÚ_wrap_idxmax_idxminr_ r Ú infer_objects) rm r¦ r§ r¨ r© rv rÉ Únew_mgrr^ Úoutrb s ``` `` @ro r zGroupBy._cython_agg_general¬ s ý ð ×*Ñ*¸ È3Ð*ÓO÷ ò ð6 ×%Ñ% jÓ1Ø×&Ñ& wÓ/Ø Ð&Ñ &Ø×*Ñ*¨3Ó/CØ×*Ñ*¨3Ó/Ø 99>Ø×#Ñ#¨Ð#Ó/CØ
|
rq c ó t | « rk ra )rm r¦ r¨ r rv s ro Ú_cython_transformzGroupBy._cython_transformÞ s ô " $Ó'Ð'rq )Úenginer} c ó |}t j |« xs |}||k7 r t | ||« t |t « s | j
|
|||g|¢i |¤S |t j vrd| d}t |« |t j v s|t j v r |
|
||d< ||d< t | |« |i |¤S t j | dd« 5 |dv r+t t d |« } | j |dg|¢i |¤}n |
|
||d< ||d< t | |« |i |¤}d d d « | j! « S # 1 sw Y xY w)Nr z2' is not a valid function name for transform(name)r× r} r TrÊ )rà Úget_cython_funcrA r» r Ú_transform_generalrP Útransform_kernel_allowlistrÍ Úcythonized_kernelsr r Ú temp_setattrr r Ú_idxmax_idxminÚ_wrap_transform_fast_result) rm râ r× r} ru rv r rÓ rò s ro Ú
|
_transformzGroupBy._transformã s ð Ü×"Ñ" 4Ó(Ò0¨DØ Ò Ü " 4¨°DÔ 9ä$¤Ô$Ø*4×*Ñ*¨4°¸ ÐXÈÒXÐQWÑXÐ Xà ×8Ñ8Ñ 8ØdVÐMÐNCÜ S/Ð !Ø T×,Ñ,Ñ ,°¼×8SÑ8SÑ0SàÐ!Ø#)xÑ Ø*7Ñ'Ø&74 Ó&¨Ð7°Ñ7Ð 7ô ×!Ñ! $¨
|
°DÓ9ñ
|
Bð Ð/Ñ/Ü ¤Ð(:Ñ ;¸TÓBDØ 0T× 0Ñ 0°°tÐ M¸dÒ MÀfÑ MFà Ð)Ø+1xÑ(Ø2?Ñ/Ø 0W T¨4Ó 0°$Ð A¸&Ñ AF÷
|
Bð ×3Ñ3°FÓ;Ð ;÷
|
Bð
|
Bús ÃAD9Ä9Ec óz | j }| j j \ }}}|j | j j | j
|
d¬« }| j j dk( rJt j |j |« }|j ||j |j ¬« }|S |j dk( rdn | j
|
}|j | j |« }|j! |||fidd¬« }|j# |j% | j
|
« |¬« }|S ) z7
|
Fast transform path for aggregations.
|
Fr) rä ©r5 r r T)Ú
|
allow_dupsr* ræ )rÚ r r/ r8 r, r r r9 r> Útake_ndr4 r r5 r r1 r7 Ú_reindex_with_indexersrE r. ) rm rò r rk rA rÔ Úoutputr Únew_axs ro rß z#GroupBy._wrap_transform_fast_result s ð
|
×'Ñ'ð MM×,Ñ, QØ § ¡ × :Ñ :ÀÇÁÐQV ÓWà 88==AÒ ä ×$Ñ$ V§^¡^°SÓ9CØ×%Ñ% c°·±ÀÇÁÐ%ÓJFð ð qÒ(1¨d¯i©iDð [[ Ñ&×+Ñ+¨CÓ0FØ×2Ñ2Ø }Ð%°$¸Uð 3ó Fð __ S§]¡]°4·9±9Ó%=ÀD_ÓIFØ rq c óx t |« dk( rt j g d¬« }n(t j t j |« « }|r)| j
|
j || j ¬« }|S t j t | j
|
j « t ¬« }|j d« d||j t « < t j |t | j
|
j dd « dgz « j" }| j
|
j% |« }|S )Nr Úint64r² ræ FTrä )r r½ Úarrayr Ú concatenaterz r7 r Úemptyr5 r Úfillr¸ rô Útilerñ r r# Úwhere)rm r± r Úfilteredr? s ro Ú _apply_filterzGroupBy._apply_filter, sð ä w<1Ò Ühhr¨Ô1Gäggbnn¨WÓ 5Ó6GÙ Ø×)Ñ)×.Ñ.¨w¸T¿Y¹YÐ.ÓGHð ô 88C × 2Ñ 2× 8Ñ 8Ó 9ÄÔFDØ IIeÔ Ø(,D ¤Ó$Ñ %ä774¤ d×&8Ñ&8×&>Ñ&>¸q¸rÐ&BÓ!CÀqÀcÑ!IÓJ×LÑLDØ×)Ñ)×/Ñ/°Ó5HØrq c óà | j j \ }}}t ||« }|| t |« }}|dk( r%t j
|
dt j ¬« S t j d|dd |dd k7 f }t j t j t j |« d |f « }| j « } |r | t j | | |« z } n2t j | t j |dd df |« | z
|
} | j j rHt j |dk( t j | j t j d¬« « } n!| j t j d¬« } t j
|
|t j" ¬« }
|
t j$ |t j" ¬« |
|
|< | |
|
S ) a.
|
Parameters
|
----------
|
ascending : bool, default True
|
If False, number in reverse, from length of group - 1 to 0.
|
|
Notes
|
-----
|
this is currently implementing sort=False
|
(though the default is sort=True) for groupby in general
|
r r² TNr( rä Fr± )r r/ r] r r½ rì ré Úr_ÚdiffÚnonzeroÚcumsumÚrepeatr rï Únanr¸ Úfloat64ÚintpÚarange) rm Ú ascendingrk rA r¯ ÚsorterÚcountÚrunÚreprÔ Úrevs ro Ú_cumcount_arrayzGroupBy._cumcount_array= sx ð --×2Ñ2QÜ'¨¨WÓ5Ø[¤# c£(Uà A:Ü88A¤R§X¡XÔ.Ð .äeeD#cr( c¨!¨" gÑ-Ð-Ñ.ÜggbeeBJJ sO¨AÑ .°Ð 5Ñ6Ó7Øtmmoá Ø 299S X sÓ+Ñ +Cä))C¤§¡ c¨!¨" g¨t mÑ 4Ñ 5°sÓ;¸cÑACà ==× 'Ò 'Ü((3 "9¤b§f¡f¨c¯j©j¼¿¹È%¨jÓ.PÓQCà**RXX¨E*Ó2Cähhu¤B§G¡GÔ,Üii ¬R¯W©WÔ5F Ø3xrq c óÆ t | j t « r| j j S t | j t « sJ | j j
|
S rk )r» r rN Ú_constructor_slicedr\ r r¡ s ro Ú_obj_1d_constructorzGroupBy._obj_1d_constructore sF ô dhh¤ Ô *Ø88×/Ñ/Ð /Ü$((¤FÔ+Ð+Ð+Øxx×$Ñ$Ð$rq rn ©r )Úsee_alsoc ó2 | j dfd¬« S )aÌ
|
Return True if any value in the group is truthful, else False.
|
|
Parameters
|
----------
|
skipna : bool, default True
|
Flag to ignore nan values during truth testing.
|
|
Returns
|
-------
|
Series or DataFrame
|
DataFrame or Series of boolean values, where a value is True if any element
|
is True within its respective group, False otherwise.
|
%(see_also)s
|
Examples
|
--------
|
For SeriesGroupBy:
|
|
>>> lst = ['a', 'a', 'b']
|
>>> ser = pd.Series([1, 2, 0], index=lst)
|
>>> ser
|
a 1
|
a 2
|
b 0
|
dtype: int64
|
>>> ser.groupby(level=0).any()
|
a True
|
b False
|
dtype: bool
|
|
For DataFrameGroupBy:
|
|
>>> data = [[1, 0, 3], [1, 0, 6], [7, 1, 9]]
|
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
|
... index=["ostrich", "penguin", "parrot"])
|
>>> df
|
a b c
|
ostrich 1 0 3
|
penguin 1 0 6
|
parrot 7 1 9
|
>>> df.groupby(by=["a"]).any()
|
b c
|
a
|
1 False True
|
7 True True
|
r c ó> t | d¬« j ¬« S ©NFr± )Úskipna)r\ r ©r r s ro r· z GroupBy.any.<locals>.<lambda>¢ ó ø & ¨Ô/×3Ñ3¸6Ð3ÓB rq ©r§ r ©r ©rm r s `ro r z GroupBy.anyn s' ø ðd ×'Ñ'Ø ÛBØð (ó
|
ð
|
rq c ó2 | j dfd¬« S )aÑ
|
Return True if all values in the group are truthful, else False.
|
|
Parameters
|
----------
|
skipna : bool, default True
|
Flag to ignore nan values during truth testing.
|
|
Returns
|
-------
|
Series or DataFrame
|
DataFrame or Series of boolean values, where a value is True if all elements
|
are True within its respective group, False otherwise.
|
%(see_also)s
|
Examples
|
--------
|
|
For SeriesGroupBy:
|
|
>>> lst = ['a', 'a', 'b']
|
>>> ser = pd.Series([1, 2, 0], index=lst)
|
>>> ser
|
a 1
|
a 2
|
b 0
|
dtype: int64
|
>>> ser.groupby(level=0).all()
|
a True
|
b False
|
dtype: bool
|
|
For DataFrameGroupBy:
|
|
>>> data = [[1, 0, 3], [1, 5, 6], [7, 8, 9]]
|
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
|
... index=["ostrich", "penguin", "parrot"])
|
>>> df
|
a b c
|
ostrich 1 0 3
|
penguin 1 5 6
|
parrot 7 8 9
|
>>> df.groupby(by=["a"]).all()
|
b c
|
a
|
1 False True
|
7 True True
|
rÅ c ó> t | d¬« j ¬« S r
|
)r\ rÅ r s ro r· z GroupBy.all.<locals>.<lambda>Û r rq r r r s `ro rÅ z GroupBy.all¦ s' ø ðf ×'Ñ'Ø ÛBØð (ó
|
ð
|
rq c ó|
|
| j « }| j j \ }
|
dk7 |j dk( d
|
fd }|j |« }| j |« }t j | dd« 5 | j |« }ddd« | j d¬« S # 1 sw Y xY w)
|
af
|
Compute count of group, excluding missing values.
|
|
Returns
|
-------
|
Series or DataFrame
|
Count of values within each group.
|
%(see_also)s
|
Examples
|
--------
|
For SeriesGroupBy:
|
|
>>> lst = ['a', 'a', 'b']
|
>>> ser = pd.Series([1, 2, np.nan], index=lst)
|
>>> ser
|
a 1.0
|
a 2.0
|
b NaN
|
dtype: float64
|
>>> ser.groupby(level=0).count()
|
a 2
|
b 0
|
dtype: int64
|
|
For DataFrameGroupBy:
|
|
>>> data = [[1, np.nan, 3], [1, np.nan, 6], [7, 8, 9]]
|
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
|
... index=["cow", "horse", "bull"])
|
>>> df
|
a b c
|
cow 1 NaN 3
|
horse 1 NaN 6
|
bull 7 8.0 9
|
>>> df.groupby("a").count()
|
b c
|
a
|
1 0 2
|
7 1 1
|
|
For Resampler:
|
|
>>> ser = pd.Series([1, 2, 3, 4], index=pd.DatetimeIndex(
|
... ['2023-01-01', '2023-01-15', '2023-02-01', '2023-02-15']))
|
>>> ser
|
2023-01-01 1
|
2023-01-15 2
|
2023-02-01 3
|
2023-02-15 4
|
dtype: int64
|
>>> ser.resample('MS').count()
|
2023-01-01 2
|
2023-02-01 2
|
Freq: MS, dtype: int64
|
r( rä c óT | j dk( r t | « j dd« z }nt | « z }t j |¬« }t | t « r@t |d t j |j d t j ¬« ¬« S t | t « rDt | j t « s*t d« }t! | « j# |d |¬« S r*|j dk( sJ |j d dk( sJ |d S |S ) Nrä r( )r> Úmax_binr r² )r? zint64[pyarrow]rv )r9 r; Úreshaper Úcount_level_2dr» rC rG r½ Úzerosr Úbool_rB r³ rI r: r« rº )ÚbvaluesÚmaskedÚcountedr³ rk Ú is_seriesr? r¯ s ro Úhfuncz GroupBy.count.<locals>.hfunc s ø à||qÒ à ¤ g£ ×!6Ñ!6°q¸"Ó!=Ð =Ñ=à ¤ g£ Ñ.ä×(Ñ(¨¸ÀWÔMGÜ'¤?Ô3Ü#ØAJ¤R§X¡X¨g¯m©m¸AÑ.>ÄbÇhÁhÔ%Oôð ô GÔ%8Ô9Ä*Ø {ôCô %Ð%5Ó6ÜG}×3Ñ3°G¸A±JÀeÐ3ÓLÐLÙØ || qÒ(Ð(Ð(Ø }} QÑ'¨1Ò,Ð,Ð,Ø qzÐ!ØNrq r TNr ©Ú
|
fill_value)r r r
r )
|
rÎ r r/ r9 rÏ rÐ rà rÝ r_ r] ) rm rb rA r rÓ Únew_objrò rk r r? r¯ s @@@@ro rþ z GroupBy.countß s¼ û ðv ×*Ñ*Ó,Ø --×2Ñ2QØbyàII N ÷ ð ð0 ×%Ñ% eÓ,Ø×*Ñ*¨7Ó3ô × Ñ d J°Ó 5ñ ;Ø×1Ñ1°'Ó:F÷ ;ð ×#Ñ# F°qÐ#Ó9Ð9÷ ;ð ;ús ÂB2Â2B;c óÔ t |« r)ddlm} | j |t j
|
|d¬« S | j dfd¬« }|j | j d¬« S ) aW
|
Compute mean of groups, excluding missing values.
|
|
Parameters
|
----------
|
numeric_only : bool, default False
|
Include only float, int, boolean columns.
|
|
.. versionchanged:: 2.0.0
|
|
numeric_only no longer accepts ``None`` and defaults to ``False``.
|
|
engine : str, default None
|
* ``'cython'`` : Runs the operation through C-extensions from cython.
|
* ``'numba'`` : Runs the operation through JIT compiled code from numba.
|
* ``None`` : Defaults to ``'cython'`` or globally setting
|
``compute.use_numba``
|
|
.. versionadded:: 1.4.0
|
|
engine_kwargs : dict, default None
|
* For ``'cython'`` engine, there are no accepted ``engine_kwargs``
|
* For ``'numba'`` engine, the engine can accept ``nopython``, ``nogil``
|
and ``parallel`` dictionary keys. The values must either be ``True`` or
|
``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is
|
``{{'nopython': True, 'nogil': False, 'parallel': False}}``
|
|
.. versionadded:: 1.4.0
|
|
Returns
|
-------
|
pandas.Series or pandas.DataFrame
|
%(see_also)s
|
Examples
|
--------
|
>>> df = pd.DataFrame({'A': [1, 1, 2, 1, 2],
|
... 'B': [np.nan, 2, 3, 4, 5],
|
... 'C': [1, 2, 1, 1, 2]}, columns=['A', 'B', 'C'])
|
|
Groupby one column and return the mean of the remaining columns in
|
each group.
|
|
>>> df.groupby('A').mean()
|
B C
|
A
|
1 3.0 1.333333
|
2 4.0 1.500000
|
|
Groupby two columns and return the mean of the remaining column.
|
|
>>> df.groupby(['A', 'B']).mean()
|
C
|
A B
|
1 2.0 2.0
|
4.0 1.0
|
2 3.0 1.0
|
5.0 2.0
|
|
Groupby one column and return the mean of only particular column in
|
the group.
|
|
>>> df.groupby('A')['B'].mean()
|
A
|
1 3.0
|
2 4.0
|
Name: B, dtype: float64
|
r )Ú grouped_mean©Ú min_periodsÚmeanc ó> t | d¬« j ¬« S ©NFr± )r¨ )r\ r& ©r r¨ s ro r· z GroupBy.mean.<locals>.<lambda> s ø f Q¨UÔ 3× 8Ñ 8ÀlÐ 8Ó S rq ©r§ r¨ rn rª ) r_ Úpandas.core._numba.kernelsr# r r@ Úfloat_dtype_mappingr r® r )rm r¨ r× r} r# rò s ` ro r& z GroupBy.meanD sw ø ôZ 6Ô "Ý ?à×*Ñ*Ø Ü×,Ñ,Ø Ø ð +ó ð ð ×-Ñ-ØÛSØ )ð .ó Fð
|
×&Ñ& t§x¡x¸ Ð&ÓBÐ Brq c ól | j dfd¬« }|j | j d¬« S )aþ
|
Compute median of groups, excluding missing values.
|
|
For multiple groupings, the result index will be a MultiIndex
|
|
Parameters
|
----------
|
numeric_only : bool, default False
|
Include only float, int, boolean columns.
|
|
.. versionchanged:: 2.0.0
|
|
numeric_only no longer accepts ``None`` and defaults to False.
|
|
Returns
|
-------
|
Series or DataFrame
|
Median of values within each group.
|
|
Examples
|
--------
|
For SeriesGroupBy:
|
|
>>> lst = ['a', 'a', 'a', 'b', 'b', 'b']
|
>>> ser = pd.Series([7, 2, 8, 4, 3, 3], index=lst)
|
>>> ser
|
a 7
|
a 2
|
a 8
|
b 4
|
b 3
|
b 3
|
dtype: int64
|
>>> ser.groupby(level=0).median()
|
a 7.0
|
b 3.0
|
dtype: float64
|
|
For DataFrameGroupBy:
|
|
>>> data = {'a': [1, 3, 5, 7, 7, 8, 3], 'b': [1, 4, 8, 4, 4, 2, 1]}
|
>>> df = pd.DataFrame(data, index=['dog', 'dog', 'dog',
|
... 'mouse', 'mouse', 'mouse', 'mouse'])
|
>>> df
|
a b
|
dog 1 1
|
dog 3 4
|
dog 5 8
|
mouse 7 4
|
mouse 7 4
|
mouse 8 2
|
mouse 3 1
|
>>> df.groupby(level=0).median()
|
a b
|
dog 3.0 4.0
|
mouse 7.0 3.0
|
|
For Resampler:
|
|
>>> ser = pd.Series([1, 2, 3, 3, 4, 5],
|
... index=pd.DatetimeIndex(['2023-01-01',
|
... '2023-01-10',
|
... '2023-01-15',
|
... '2023-02-01',
|
... '2023-02-10',
|
... '2023-02-15']))
|
>>> ser.resample('MS').median()
|
2023-01-01 2.0
|
2023-02-01 4.0
|
Freq: MS, dtype: float64
|
Úmedianc ó> t | d¬« j ¬« S r( )r\ r. r) s ro r· z GroupBy.median.<locals>.<lambda>í s ø & ¨Ô/×6Ñ6ÀLÐ6ÓQ rq r* rn rª r¬ )rm r¨ rò s ` ro r. zGroupBy.median¢ s@ ø ðR ×)Ñ)Ø ÛQØ%ð *ó
|
ð
|
×"Ñ" 4§8¡8°IÐ"Ó>Ð>rq rä c óÄ t |« r=ddlm} t j | j |t j |d¬« « S | j dfd|¬« S )a
|
Compute standard deviation of groups, excluding missing values.
|
|
For multiple groupings, the result index will be a MultiIndex.
|
|
Parameters
|
----------
|
ddof : int, default 1
|
Degrees of freedom.
|
|
engine : str, default None
|
* ``'cython'`` : Runs the operation through C-extensions from cython.
|
* ``'numba'`` : Runs the operation through JIT compiled code from numba.
|
* ``None`` : Defaults to ``'cython'`` or globally setting
|
``compute.use_numba``
|
|
.. versionadded:: 1.4.0
|
|
engine_kwargs : dict, default None
|
* For ``'cython'`` engine, there are no accepted ``engine_kwargs``
|
* For ``'numba'`` engine, the engine can accept ``nopython``, ``nogil``
|
and ``parallel`` dictionary keys. The values must either be ``True`` or
|
``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is
|
``{{'nopython': True, 'nogil': False, 'parallel': False}}``
|
|
.. versionadded:: 1.4.0
|
|
numeric_only : bool, default False
|
Include only `float`, `int` or `boolean` data.
|
|
.. versionadded:: 1.5.0
|
|
.. versionchanged:: 2.0.0
|
|
numeric_only now defaults to ``False``.
|
|
Returns
|
-------
|
Series or DataFrame
|
Standard deviation of values within each group.
|
%(see_also)s
|
Examples
|
--------
|
For SeriesGroupBy:
|
|
>>> lst = ['a', 'a', 'a', 'b', 'b', 'b']
|
>>> ser = pd.Series([7, 2, 8, 4, 3, 3], index=lst)
|
>>> ser
|
a 7
|
a 2
|
a 8
|
b 4
|
b 3
|
b 3
|
dtype: int64
|
>>> ser.groupby(level=0).std()
|
a 3.21455
|
b 0.57735
|
dtype: float64
|
|
For DataFrameGroupBy:
|
|
>>> data = {'a': [1, 3, 5, 7, 7, 8, 3], 'b': [1, 4, 8, 4, 4, 2, 1]}
|
>>> df = pd.DataFrame(data, index=['dog', 'dog', 'dog',
|
... 'mouse', 'mouse', 'mouse', 'mouse'])
|
>>> df
|
a b
|
dog 1 1
|
dog 3 4
|
dog 5 8
|
mouse 7 4
|
mouse 7 4
|
mouse 8 2
|
mouse 3 1
|
>>> df.groupby(level=0).std()
|
a b
|
dog 2.000000 3.511885
|
mouse 2.217356 1.500000
|
r ©Ú grouped_var©r% ÚddofrÆ c ó> t | d¬« j ¬« S ©NFr± )r4 )r\ rÆ ©r r4 s ro r· z GroupBy.std.<locals>.<lambda>Z
|
ó ø f Q¨UÔ 3× 7Ñ 7¸TÐ 7Ó B rq ©r§ r¨ r4 ) r_ r+ r2 r½ Úsqrtr r@ r, r ©rm r4 r× r} r¨ r2 s ` ro rÆ z GroupBy.stdò sp ø ôr 6Ô "Ý >ä77Ø×'Ñ'Ø Ü ×0Ñ0Ø!Ø !Ø ð (ó óð ð ×+Ñ+ØÛBØ )Øð ,ó ð rq c ó t |« r*ddlm} | j |t j
|
|d¬« S | j dfd|¬« S )a
|
Compute variance of groups, excluding missing values.
|
|
For multiple groupings, the result index will be a MultiIndex.
|
|
Parameters
|
----------
|
ddof : int, default 1
|
Degrees of freedom.
|
|
engine : str, default None
|
* ``'cython'`` : Runs the operation through C-extensions from cython.
|
* ``'numba'`` : Runs the operation through JIT compiled code from numba.
|
* ``None`` : Defaults to ``'cython'`` or globally setting
|
``compute.use_numba``
|
|
.. versionadded:: 1.4.0
|
|
engine_kwargs : dict, default None
|
* For ``'cython'`` engine, there are no accepted ``engine_kwargs``
|
* For ``'numba'`` engine, the engine can accept ``nopython``, ``nogil``
|
and ``parallel`` dictionary keys. The values must either be ``True`` or
|
``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is
|
``{{'nopython': True, 'nogil': False, 'parallel': False}}``
|
|
.. versionadded:: 1.4.0
|
|
numeric_only : bool, default False
|
Include only `float`, `int` or `boolean` data.
|
|
.. versionadded:: 1.5.0
|
|
.. versionchanged:: 2.0.0
|
|
numeric_only now defaults to ``False``.
|
|
Returns
|
-------
|
Series or DataFrame
|
Variance of values within each group.
|
%(see_also)s
|
Examples
|
--------
|
For SeriesGroupBy:
|
|
>>> lst = ['a', 'a', 'a', 'b', 'b', 'b']
|
>>> ser = pd.Series([7, 2, 8, 4, 3, 3], index=lst)
|
>>> ser
|
a 7
|
a 2
|
a 8
|
b 4
|
b 3
|
b 3
|
dtype: int64
|
>>> ser.groupby(level=0).var()
|
a 10.333333
|
b 0.333333
|
dtype: float64
|
|
For DataFrameGroupBy:
|
|
>>> data = {'a': [1, 3, 5, 7, 7, 8, 3], 'b': [1, 4, 8, 4, 4, 2, 1]}
|
>>> df = pd.DataFrame(data, index=['dog', 'dog', 'dog',
|
... 'mouse', 'mouse', 'mouse', 'mouse'])
|
>>> df
|
a b
|
dog 1 1
|
dog 3 4
|
dog 5 8
|
mouse 7 4
|
mouse 7 4
|
mouse 8 2
|
mouse 3 1
|
>>> df.groupby(level=0).var()
|
a b
|
dog 4.000000 12.333333
|
mouse 4.916667 2.250000
|
r r1 r3 Úvarc ó> t | d¬« j ¬« S r6 )r\ r= r7 s ro r· z GroupBy.var.<locals>.<lambda>Å
|
r8 rq r9 )r_ r+ r2 r r@ r, r r; s ` ro r= z GroupBy.var_
|
sd ø ôr 6Ô "Ý >à×*Ñ*ØÜ×,Ñ,Ø Ø Øð +ó ð ð ×+Ñ+ØÛBØ )Øð ,ó ð rq c óÀ | j dk( r t d« |rdnd}| j }| j }| j j
|
D ch c] } | j s| j }
|
} t |t « r|j } | |
|
v rg n|g} nt |j « } |@t |« }|t |
|
« z }|rt d| d« || z
|
}|rt d| d« | }t |j « D cg c] \ }} | |
|
vr| |v r|j dd
|f " } }} t | j j
|
« }| D ]C }t! ||| j | j" d |¬
|
« \ }}}|t |j
|
« z }E |j% || j" | j& | j( ¬ « }t+ t |j- « « }||_ t/ d |D « « r[|D cg c] }|j0 }}t3 j4 ||D cg c] }|j c}¬ « }|j7 |d¬« }|r|j9 |d¬« }| j" r|j: j< }t? tA |« « |j: _ t t? tA | j j
|
« « « } |jC | d ¬« }||j: _ |rt t? tA | j j
|
« |j: jD « « } |j% |j: jG | « | j" | j( d ¬« jI d« } || z }|jK d« }| jL r|} nã|j: } tO jP | j< « }!||!v rt d| d« ||_ | jS t? tA |!« « « |_ |jU « }"| j j
|
d j j jV }#tY |!|#¬« j[ tA |!« |« }$|$|"_ |"} | j] | j d¬« S c c} w c c} }w c c}w c c}w )zø
|
Shared implementation of value_counts for SeriesGroupBy and DataFrameGroupBy.
|
|
SeriesGroupBy additionally supports a bins argument. See the docstring of
|
DataFrameGroupBy.value_counts for a description of arguments.
|
rä z1DataFrameGroupBy.value_counts only handles axis=0Ú
|
proportionrþ NzKeys z0 in subset cannot be in the groupby column keys.z) in subset do not exist in the DataFrame.F)r¶ r r r r )r r r c 3 óz K | ]3 }t |j t t f« xr |j 5 y wrk )r» Úgrouping_vectorrD rV Ú _observed)rà Úgroupings ro rÅ z(GroupBy._value_counts.<locals>.<genexpr> sC è ø ò
|
ð ô x×/Ñ/´+Ô?OÐ1PÓ Qò 'Ø ×&Ñ&Ð&ó 'ñ
|
ùs 9;©rÐ r r Ústable)rü Úkind)r Úsort_remaining)r r r Úsumg zColumn label 'z ' is duplicate of result columnr² Ú value_countsrª )/r rh r rÚ r r rQ r r» r\ ÚsetrN rÍ Ú enumeraterè rñ rS r rn r r r Úsizer Ú _result_indexrX Ú from_productr8 Ú sort_valuesr5 rÐ r- r rG ÚnlevelsÚ droplevelÚ transformr r rà Úfill_missing_namesÚ set_namesÚ reset_indexr³ rW rR r® )%rm ÚsubsetÚ normalizer rü r r r r rD Ú in_axis_namesÚ_namer Ú unique_colsÚ subsettedÚclashingÚ doesnt_existÚidxr r¶ r rA ÚgbÚ result_seriesr Ú levels_listÚ multi_indexrÐ Ú index_levelr' Úindexed_group_sizerò r5 rN Ú result_frameÚ
|
orig_dtypeÚcolss% ro Ú _value_countszGroupBy._value_countsÊ
|
s ð 99>Ü%ØCóð ñ )|¨gà XXØ×'Ñ'ð +/¯-©-×*AÑ*Aö
|
Ø &ÀX×EUÓEUHMMð
|
ð
|
ô c6Ô "ØHHEØ -Ñ/2°c°UDä ckkÓ*KØÐ!Ü K Ø$¤s¨=Ó'9Ñ9ÙÜ$Ø zð *3ð 3óð ð )¨;Ñ 6 Ù Ü$Ø ~ð .2ð 3óð ð
|
( ô
|
#,¨C¯K©KÓ"8÷ñ CØ Ñ-°%¸9Ñ2Dð CÓ ðDñ ô ×0Ñ0Ó1 Øò 1CÜ 'ØØØYYØYYØ Ø ô MGQð g× /Ñ /Ó0Ñ 0Ið 1ð ZZØ ØØ]]Ø;;ð ó
|
ô V R§W¡W£YÓ/ Ø ! Ôô ñ
|
ð &ô
|
ô
|
ð
|
;DÖD°$4×-Ó-ÐDKÐDÜ$×1Ñ1ظ)Ö#D°$ D§I£IÒ#DôKð *× 1Ñ 1°+È!Ð 1Ó LMá à )× 5Ñ 5Ø#¨(ð 6ó Mð 99à!×'Ñ'×-Ñ-Eä(-¬c°%«jÓ(9M× Ñ Ô %Ü u¤S¨¯ © ×)@Ñ)@Ó%AÓ BÓCKØ )× 4Ñ 4Ø!°%ð 5ó Mð ).M× Ñ Ô %á ô Üc$--×1Ñ1Ó2°M×4GÑ4G×4OÑ4OÓPóFð "/×!6Ñ!6Ø ×#Ñ#×-Ñ-¨fÓ5ØYYØ{{à ð "7ó "÷ iÓ ð ð Ð /Ñ /Mð *× 0Ñ 0°Ó 5Mð ==Ø"Fð "×'Ñ'EÜ×,Ñ,¨U¯[©[Ó9GØwÜ >°$°Ð7VÐ!WÓXÐXØ!%MÔ Ø"'§/¡/´%¼¸G» Ó2EÓ"FMÔ Ø(×4Ñ4Ó6LØ ×0Ñ0°Ñ3×7Ñ7×?Ñ?×EÑEJܨ
|
Ô3×:Ñ:¼3¸w»<ÈÓNDØ#'LÔ Ø!FØ×"Ñ" 4§8¡8°NÐ"ÓCÐCùòm
|
ùó2ùòH Eùâ#Ds ÁS Á#S Ä
|
%SÈSÈ0S
|
c ó |rr| j j dk( rYt | j j « s:t t | « j d| d| j j « | j dfd|¬« S )a+
|
Compute standard error of the mean of groups, excluding missing values.
|
|
For multiple groupings, the result index will be a MultiIndex.
|
|
Parameters
|
----------
|
ddof : int, default 1
|
Degrees of freedom.
|
|
numeric_only : bool, default False
|
Include only `float`, `int` or `boolean` data.
|
|
.. versionadded:: 1.5.0
|
|
.. versionchanged:: 2.0.0
|
|
numeric_only now defaults to ``False``.
|
|
Returns
|
-------
|
Series or DataFrame
|
Standard error of the mean of values within each group.
|
|
Examples
|
--------
|
For SeriesGroupBy:
|
|
>>> lst = ['a', 'a', 'b', 'b']
|
>>> ser = pd.Series([5, 10, 8, 14], index=lst)
|
>>> ser
|
a 5
|
a 10
|
b 8
|
b 14
|
dtype: int64
|
>>> ser.groupby(level=0).sem()
|
a 2.5
|
b 3.0
|
dtype: float64
|
|
For DataFrameGroupBy:
|
|
>>> data = [[1, 12, 11], [1, 15, 2], [2, 5, 8], [2, 6, 12]]
|
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
|
... index=["tuna", "salmon", "catfish", "goldfish"])
|
>>> df
|
a b c
|
tuna 1 12 11
|
salmon 1 15 2
|
catfish 2 5 8
|
goldfish 2 6 12
|
>>> df.groupby("a").sem()
|
b c
|
a
|
1 1.5 4.5
|
2 0.5 2.0
|
|
For Resampler:
|
|
>>> ser = pd.Series([1, 3, 2, 4, 3, 8],
|
... index=pd.DatetimeIndex(['2023-01-01',
|
... '2023-01-10',
|
... '2023-01-15',
|
... '2023-02-01',
|
... '2023-02-10',
|
... '2023-02-15']))
|
>>> ser.resample('MS').sem()
|
2023-01-01 0.577350
|
2023-02-01 1.527525
|
Freq: MS, dtype: float64
|
rä z .sem called with numeric_only=z and dtype rÇ c ó> t | d¬« j ¬« S r6 )r\ rÇ r7 s ro r· z GroupBy.sem.<locals>.<lambda>« s ø & ¨Ô/×3Ñ3¸Ð3Ó> rq r9 )r r9 r5 r³ r r« rx r )rm r4 r¨ s ` ro rÇ z GroupBy.semZ s ø ñT DHHMM¨QÒ .Ô7GÈÏÉÏÉÔ7WÜÜ:×&Ñ&Ð'ð ( Ø ,~¨[¸¿¹¿ ¹ Ð8HðJóð ð ×'Ñ'Ø Û>Ø%Øð (ó
|
ð
|
rq c óR | j j « }d}t | j t « rt | j j
|
t « rQt | j j
|
t « rd}nPt | j j
|
t « rd}n)d}n&t | j j
|
t « rd}t | j t « r(| j || j j ¬« }n| j |« }||j dddd|¬« }t j | dd« 5 | j |d ¬
|
« }ddd« | j s |j# d « j% « }|S # 1 sw Y 6xY w) a:
|
Compute group sizes.
|
|
Returns
|
-------
|
DataFrame or Series
|
Number of rows in each group as a Series if as_index is True
|
or a DataFrame if as_index is False.
|
%(see_also)s
|
Examples
|
--------
|
|
For SeriesGroupBy:
|
|
>>> lst = ['a', 'a', 'b']
|
>>> ser = pd.Series([1, 2, 3], index=lst)
|
>>> ser
|
a 1
|
a 2
|
b 3
|
dtype: int64
|
>>> ser.groupby(level=0).size()
|
a 2
|
b 1
|
dtype: int64
|
|
>>> data = [[1, 2, 3], [1, 5, 6], [7, 8, 9]]
|
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
|
... index=["owl", "toucan", "eagle"])
|
>>> df
|
a b c
|
owl 1 2 3
|
toucan 1 5 6
|
eagle 7 8 9
|
>>> df.groupby("a").size()
|
a
|
1 2
|
7 1
|
dtype: int64
|
|
For Resampler:
|
|
>>> ser = pd.Series([1, 2, 3], index=pd.DatetimeIndex(
|
... ['2023-01-01', '2023-01-15', '2023-02-01']))
|
>>> ser
|
2023-01-01 1
|
2023-01-15 2
|
2023-02-01 3
|
dtype: int64
|
>>> ser.resample('MS').size()
|
2023-01-01 2
|
2023-02-01 1
|
Freq: MS, dtype: int64
|
NÚnumpy_nullableÚpyarrowr F)rÒ Úconvert_stringÚconvert_booleanÚconvert_floatingÚ dtype_backendr Tr r rM )r rM r» r r\ rê rB rK rJ rC r r Úconvert_dtypesrà rÝ r] r ÚrenamerV )rm rò rr s ro rM z GroupBy.size° s[ ðt ×#Ñ#Ó%ØEI Ü dhh¤Ô 'Ü$((..Ô*=Ô>Ü dhhnnÔ.LÔMØ$(MÜ §¡§¡Ô0@ÔAØ$4Mà$-MÜDHHNN¬OÔ<Ø 0 ô dhh¤Ô 'Ø×-Ñ-¨f¸4¿8¹8¿=¹=Ð-ÓIFà×-Ñ-¨fÓ5Fà Ð $Ø×*Ñ*Ø #Ø $Ø %Ø!&Ø +ð +ó Fô × Ñ d J°Ó 5ñ @ð ×)Ñ)¨&¸QÐ)Ó?F÷ @ð }}ð ]] 6Ó*×6Ñ6Ó8FØ ÷ @ð @ús ÅF Æ F&rI a For SeriesGroupBy:
|
|
>>> lst = ['a', 'a', 'b', 'b']
|
>>> ser = pd.Series([1, 2, 3, 4], index=lst)
|
>>> ser
|
a 1
|
a 2
|
b 3
|
b 4
|
dtype: int64
|
>>> ser.groupby(level=0).sum()
|
a 3
|
b 7
|
dtype: int64
|
|
For DataFrameGroupBy:
|
|
>>> data = [[1, 8, 2], [1, 2, 5], [2, 5, 8], [2, 6, 9]]
|
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
|
... index=["tiger", "leopard", "cheetah", "lion"])
|
>>> df
|
a b c
|
tiger 1 8 2
|
leopard 1 2 5
|
cheetah 2 5 8
|
lion 2 6 9
|
>>> df.groupby("a").sum()
|
b c
|
a
|
1 10 7
|
2 11 17)ÚfnameÚnoÚmcÚeÚekÚexamplec ó0 t |« r)ddlm} | j |t j
|
||¬« S t j | dd« 5 | j ||dt j ¬« }d d d « | j dd¬« S # 1 sw Y xY w) Nr )Ú grouped_sumr$ r TrI ©r¨ r© r r¤ )r r« ) r_ r+ r| r r@ Údefault_dtype_mappingrà rÝ r¯ r½ rI r] )rm r¨ r© r× r} r| rò s ro rI z GroupBy.sum s¢ ôd 6Ô "Ý >à×*Ñ*ØÜ×.Ñ.Ø Ø %ð +ó ð ô ×!Ñ! $¨
|
°DÓ9ñ Ø ×*Ñ*Ø!-Ø 'Ø Ü 66ð +ó ÷ ð ×'Ñ'¨¸1ÀUÐ'ÓKÐ K÷ ð ús Á $B  BÚproda For SeriesGroupBy:
|
|
>>> lst = ['a', 'a', 'b', 'b']
|
>>> ser = pd.Series([1, 2, 3, 4], index=lst)
|
>>> ser
|
a 1
|
a 2
|
b 3
|
b 4
|
dtype: int64
|
>>> ser.groupby(level=0).prod()
|
a 2
|
b 12
|
dtype: int64
|
|
For DataFrameGroupBy:
|
|
>>> data = [[1, 8, 2], [1, 2, 5], [2, 5, 8], [2, 6, 9]]
|
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
|
... index=["tiger", "leopard", "cheetah", "lion"])
|
>>> df
|
a b c
|
tiger 1 8 2
|
leopard 1 2 5
|
cheetah 2 5 8
|
lion 2 6 9
|
>>> df.groupby("a").prod()
|
b c
|
a
|
1 16 10
|
2 30 72)ru rv rw rz c óH | j ||dt j ¬« S )Nr r} )r¯ r½ r )rm r¨ r© s ro r z GroupBy.prodZ s- ðT × Ñ Ø%°À&ÔQS×QXÑQXð !ó
|
ð
|
rq Úmina For SeriesGroupBy:
|
|
>>> lst = ['a', 'a', 'b', 'b']
|
>>> ser = pd.Series([1, 2, 3, 4], index=lst)
|
>>> ser
|
a 1
|
a 2
|
b 3
|
b 4
|
dtype: int64
|
>>> ser.groupby(level=0).min()
|
a 1
|
b 3
|
dtype: int64
|
|
For DataFrameGroupBy:
|
|
>>> data = [[1, 8, 2], [1, 2, 5], [2, 5, 8], [2, 6, 9]]
|
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
|
... index=["tiger", "leopard", "cheetah", "lion"])
|
>>> df
|
a b c
|
tiger 1 8 2
|
leopard 1 2 5
|
cheetah 2 5 8
|
lion 2 6 9
|
>>> df.groupby("a").min()
|
b c
|
a
|
1 2 2
|
2 5 8c ó² t |« r*ddlm} | j |t j
|
||d¬« S | j ||dt j ¬« S )Nr ©Úgrouped_min_maxF©r% Úis_maxr r} ) r_ r+ r r r@ Úidentity_dtype_mappingr¯ r½ r ©rm r¨ r© r× r} r s ro r z GroupBy.min sg ôd 6Ô "Ý Bà×*Ñ*Ø Ü×/Ñ/Ø Ø %Ø ð +ó ð ð ×$Ñ$Ø )Ø#ØÜvvð %ó ð rq Úmaxa For SeriesGroupBy:
|
|
>>> lst = ['a', 'a', 'b', 'b']
|
>>> ser = pd.Series([1, 2, 3, 4], index=lst)
|
>>> ser
|
a 1
|
a 2
|
b 3
|
b 4
|
dtype: int64
|
>>> ser.groupby(level=0).max()
|
a 2
|
b 4
|
dtype: int64
|
|
For DataFrameGroupBy:
|
|
>>> data = [[1, 8, 2], [1, 2, 5], [2, 5, 8], [2, 6, 9]]
|
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
|
... index=["tiger", "leopard", "cheetah", "lion"])
|
>>> df
|
a b c
|
tiger 1 8 2
|
leopard 1 2 5
|
cheetah 2 5 8
|
lion 2 6 9
|
>>> df.groupby("a").max()
|
b c
|
a
|
1 8 5
|
2 6 9c ó² t |« r*ddlm} | j |t j
|
||d¬« S | j ||dt j ¬« S )Nr r Tr
r r} ) r_ r+ r r r@ r r¯ r½ r r s ro r z GroupBy.maxÌ sg ôd 6Ô "Ý Bà×*Ñ*Ø Ü×/Ñ/Ø Ø %Øð +ó ð ð ×$Ñ$Ø )Ø#ØÜvvð %ó ð rq c ó8 ddd}| j ||d||¬« S )a¥
|
Compute the first entry of each column within each group.
|
|
Defaults to skipping NA elements.
|
|
Parameters
|
----------
|
numeric_only : bool, default False
|
Include only float, int, boolean columns.
|
min_count : int, default -1
|
The required number of valid values to perform the operation. If fewer
|
than ``min_count`` valid values are present the result will be NA.
|
skipna : bool, default True
|
Exclude NA/null values. If an entire row/column is NA, the result
|
will be NA.
|
|
.. versionadded:: 2.2.1
|
|
Returns
|
-------
|
Series or DataFrame
|
First values within each group.
|
|
See Also
|
--------
|
DataFrame.groupby : Apply a function groupby to each row or column of a
|
DataFrame.
|
pandas.core.groupby.DataFrameGroupBy.last : Compute the last non-null entry
|
of each column.
|
pandas.core.groupby.DataFrameGroupBy.nth : Take the nth row from each group.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame(dict(A=[1, 1, 3], B=[None, 5, 6], C=[1, 2, 3],
|
... D=['3/11/2000', '3/12/2000', '3/13/2000']))
|
>>> df['D'] = pd.to_datetime(df['D'])
|
>>> df.groupby("A").first()
|
B C D
|
A
|
1 5.0 1 2000-03-11
|
3 6.0 3 2000-03-13
|
>>> df.groupby("A").first(min_count=2)
|
B C D
|
A
|
1 NaN 1.0 2000-03-11
|
3 NaN NaN NaT
|
>>> df.groupby("A").first(numeric_only=True)
|
B C
|
A
|
1 5.0 1
|
3 6.0 3
|
c ó¨ dd}t | t « r| j ||¬« S t | t « r || « S t t | « « )Nc ó¦ | j t | j « }t |« s | j j j S |d S )z-Helper function for first item that isn't NA.r ©rê r= r r³ Úna_value©r Úarrs ro Úfirstz2GroupBy.first.<locals>.first_compat.<locals>.firstJ s< àgge A§G¡GnÑ-Ü3xØ 77==×1Ñ1Ð1Ø1v rq ræ ©r r\ ©r» rN ry r\ r r« )r r r s ro Ú first_compatz#GroupBy.first.<locals>.first_compatI sI ó ô #yÔ)Øyy ¨TyÓ2Ð2ÜC¤Ô(Ù SzÐ!ä ¤ S£ Ó*Ð*rq r ©r¨ r© r r¤ r ©r ©r r r r ©r¯ )rm r¨ r© r r s ro r z GroupBy.first s1 ôr +ð × Ñ Ø%Ø ØØ Øð !ó
|
ð
|
rq c ó8 ddd}| j ||d||¬« S )aS
|
Compute the last entry of each column within each group.
|
|
Defaults to skipping NA elements.
|
|
Parameters
|
----------
|
numeric_only : bool, default False
|
Include only float, int, boolean columns. If None, will attempt to use
|
everything, then use only numeric data.
|
min_count : int, default -1
|
The required number of valid values to perform the operation. If fewer
|
than ``min_count`` valid values are present the result will be NA.
|
skipna : bool, default True
|
Exclude NA/null values. If an entire row/column is NA, the result
|
will be NA.
|
|
.. versionadded:: 2.2.1
|
|
Returns
|
-------
|
Series or DataFrame
|
Last of values within each group.
|
|
See Also
|
--------
|
DataFrame.groupby : Apply a function groupby to each row or column of a
|
DataFrame.
|
pandas.core.groupby.DataFrameGroupBy.first : Compute the first non-null entry
|
of each column.
|
pandas.core.groupby.DataFrameGroupBy.nth : Take the nth row from each group.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame(dict(A=[1, 1, 3], B=[5, None, 6], C=[1, 2, 3]))
|
>>> df.groupby("A").last()
|
B C
|
A
|
1 5.0 2
|
3 6.0 3
|
c ó¨ dd}t | t « r| j ||¬« S t | t « r || « S t t | « « )Nc ó¦ | j t | j « }t |« s | j j j S |d S )z,Helper function for last item that isn't NA.r( r r s ro Úlastz/GroupBy.last.<locals>.last_compat.<locals>.last s< àgge A§G¡GnÑ-Ü3xØ 77==×1Ñ1Ð1Ø2wrq ræ r r )r r r s ro Ú last_compatz!GroupBy.last.<locals>.last_compat sI ó ô #yÔ)Øyy ¨DyÓ1Ð1ÜC¤Ô(ÙCyÐ ä ¤ S£ Ó*Ð*rq r r r r r )rm r¨ r© r r s ro r z GroupBy.last` s1 ô\ +ð × Ñ Ø%Ø ØØ Øð !ó
|
ð
|
rq c ó | j j dk( r| j }t |j « }|s t d« | j j d|j ddd¬« }g d¢}| j j || j j |¬ « }| j |« S | j d
|
« }|S ) aË
|
Compute open, high, low and close values of a group, excluding missing values.
|
|
For multiple groupings, the result index will be a MultiIndex
|
|
Returns
|
-------
|
DataFrame
|
Open, high, low and close values within each group.
|
|
Examples
|
--------
|
|
For SeriesGroupBy:
|
|
>>> lst = ['SPX', 'CAC', 'SPX', 'CAC', 'SPX', 'CAC', 'SPX', 'CAC',]
|
>>> ser = pd.Series([3.4, 9.0, 7.2, 5.2, 8.8, 9.4, 0.1, 0.5], index=lst)
|
>>> ser
|
SPX 3.4
|
CAC 9.0
|
SPX 7.2
|
CAC 5.2
|
SPX 8.8
|
CAC 9.4
|
SPX 0.1
|
CAC 0.5
|
dtype: float64
|
>>> ser.groupby(level=0).ohlc()
|
open high low close
|
CAC 9.0 9.4 0.5 0.5
|
SPX 3.4 8.8 0.1 0.1
|
|
For DataFrameGroupBy:
|
|
>>> data = {2022: [1.2, 2.3, 8.9, 4.5, 4.4, 3, 2 , 1],
|
... 2023: [3.4, 9.0, 7.2, 5.2, 8.8, 9.4, 8.2, 1.0]}
|
>>> df = pd.DataFrame(data, index=['SPX', 'CAC', 'SPX', 'CAC',
|
... 'SPX', 'CAC', 'SPX', 'CAC'])
|
>>> df
|
2022 2023
|
SPX 1.2 3.4
|
CAC 2.3 9.0
|
SPX 8.9 7.2
|
CAC 4.5 5.2
|
SPX 4.4 8.8
|
CAC 3.0 9.4
|
SPX 2.0 8.2
|
CAC 1.0 1.0
|
>>> df.groupby(level=0).ohlc()
|
2022 2023
|
open high low close open high low close
|
CAC 2.3 4.5 1.0 1.0 9.0 9.4 1.0 1.0
|
SPX 1.2 8.9 1.2 2.0 3.4 8.8 3.4 8.2
|
|
For Resampler:
|
|
>>> ser = pd.Series([1, 3, 2, 4, 3, 5],
|
... index=pd.DatetimeIndex(['2023-01-01',
|
... '2023-01-10',
|
... '2023-01-15',
|
... '2023-02-01',
|
... '2023-02-10',
|
... '2023-02-15']))
|
>>> ser.resample('MS').ohlc()
|
open high low close
|
2023-01-01 1 3 1 2
|
2023-02-01 4 5 3 5
|
rä z No numeric types to aggregater Úohlcr r( rà )ÚopenÚhighÚlowÚclose)r5 rN c ó" | j « S rk )r )Úsgbs ro r· z GroupBy.ohlc.<locals>.<lambda>ü s ¸C¿H¹H»J rq ) r r9 rz r5 r³ r' r rÈ r4 Ú_constructor_expanddimr, r] Ú_apply_to_column_groupbys)rm r Ú
|
is_numericr¼ Ú agg_namesrò s ro r z GroupBy.ohlc¥ s¿ ðL 88==AÒ Ø×$Ñ$Cä)¨#¯)©)Ó4JÙ Ü Ð ?Ó@Ð@à ×8Ñ8ØS[[¨&°qÀBð 9ó Jò 9IØXX×4Ñ4Ø $§-¡-×"<Ñ"<Àið 5ó Fð ×'Ñ'¨Ó/Ð /à×/Ñ/Ñ0FÓGØ rq c óF | j }t |« dk( r]|j ¬« }|j dk( r|}n|j « }|j « j j d d S t j | dd« 5 | j fd|d¬« }d d d « | j dk( r j S j « }| j s*| j |« }t t |« « |_ |S # 1 sw Y lxY w)Nr ©Ú percentilesÚincludeÚexcluderä r Tc ó, | j ¬« S )Nr¬ )Údescribe)r r¯ r® r s ro r· z"GroupBy.describe.<locals>.<lambda> s ø !**Ø +°WÀgð %ó rq ©r )rÚ r r± r9 ÚunstackrM r# rè rà rÝ ry r r rU rZ r5 )rm r r® r¯ r Ú describedrò s ``` ro r± zGroupBy.describeÿ s ú ð ×'Ñ'ä s8q=Ø Ø '°À'ð %ó Ið xx1}Ø"à"×*Ñ*Ó,Ø??Ó$×&Ñ&×+Ñ+¨B¨QÐ/Ð /ä × Ñ d J°Ó 5ñ Ø×/Ñ/õð Ø!%ð 0ó F÷ ð 99>Ø88Oð Ó!Ø}}Ø×0Ñ0°Ó8FÜ(¬¨V«Ó5FLà ÷# ð ús ÂDÄD c ó, ddl m} || |g|¢d|i|¤S )a
|
Provide resampling when using a TimeGrouper.
|
|
Given a grouper, the function resamples it according to a string
|
"string" -> "frequency".
|
|
See the :ref:`frequency aliases <timeseries.offset_aliases>`
|
documentation for more details.
|
|
Parameters
|
----------
|
rule : str or DateOffset
|
The offset string or object representing target grouper conversion.
|
*args
|
Possible arguments are `how`, `fill_method`, `limit`, `kind` and
|
`on`, and other arguments of `TimeGrouper`.
|
include_groups : bool, default True
|
When True, will attempt to include the groupings in the operation in
|
the case that they are columns of the DataFrame. If this raises a
|
TypeError, the result will be computed with the groupings excluded.
|
When False, the groupings will be excluded when applying ``func``.
|
|
.. versionadded:: 2.2.0
|
|
.. deprecated:: 2.2.0
|
|
Setting include_groups to True is deprecated. Only the value
|
False will be allowed in a future version of pandas.
|
|
**kwargs
|
Possible arguments are `how`, `fill_method`, `limit`, `kind` and
|
`on`, and other arguments of `TimeGrouper`.
|
|
Returns
|
-------
|
pandas.api.typing.DatetimeIndexResamplerGroupby,
|
pandas.api.typing.PeriodIndexResamplerGroupby, or
|
pandas.api.typing.TimedeltaIndexResamplerGroupby
|
Return a new groupby object, with type depending on the data
|
being resampled.
|
|
See Also
|
--------
|
Grouper : Specify a frequency to resample with when
|
grouping by a key.
|
DatetimeIndex.resample : Frequency conversion and resampling of
|
time series.
|
|
Examples
|
--------
|
>>> idx = pd.date_range('1/1/2000', periods=4, freq='min')
|
>>> df = pd.DataFrame(data=4 * [range(2)],
|
... index=idx,
|
... columns=['a', 'b'])
|
>>> df.iloc[2, 0] = 5
|
>>> df
|
a b
|
2000-01-01 00:00:00 0 1
|
2000-01-01 00:01:00 0 1
|
2000-01-01 00:02:00 5 1
|
2000-01-01 00:03:00 0 1
|
|
Downsample the DataFrame into 3 minute bins and sum the values of
|
the timestamps falling into a bin.
|
|
>>> df.groupby('a').resample('3min', include_groups=False).sum()
|
b
|
a
|
0 2000-01-01 00:00:00 2
|
2000-01-01 00:03:00 1
|
5 2000-01-01 00:00:00 1
|
|
Upsample the series into 30 second bins.
|
|
>>> df.groupby('a').resample('30s', include_groups=False).sum()
|
b
|
a
|
0 2000-01-01 00:00:00 1
|
2000-01-01 00:00:30 0
|
2000-01-01 00:01:00 1
|
2000-01-01 00:01:30 0
|
2000-01-01 00:02:00 0
|
2000-01-01 00:02:30 0
|
2000-01-01 00:03:00 1
|
5 2000-01-01 00:02:00 1
|
|
Resample by month. Values are assigned to the month of the period.
|
|
>>> df.groupby('a').resample('ME', include_groups=False).sum()
|
b
|
a
|
0 2000-01-31 3
|
5 2000-01-31 1
|
|
Downsample the series into 3 minute bins as above, but close the right
|
side of the bin interval.
|
|
>>> (
|
... df.groupby('a')
|
... .resample('3min', closed='right', include_groups=False)
|
... .sum()
|
... )
|
b
|
a
|
0 1999-12-31 23:57:00 1
|
2000-01-01 00:00:00 2
|
5 2000-01-01 00:00:00 1
|
|
Downsample the series into 3 minute bins and close the right side of
|
the bin interval, but label each bin using the right edge instead of
|
the left.
|
|
>>> (
|
... df.groupby('a')
|
... .resample('3min', closed='right', label='right', include_groups=False)
|
... .sum()
|
... )
|
b
|
a
|
0 2000-01-01 00:00:00 1
|
2000-01-01 00:03:00 2
|
5 2000-01-01 00:03:00 1
|
r )Úget_resampler_for_groupingr )Úpandas.core.resampler¶ )rm Úruler ru rv r¶ s ro ÚresamplezGroupBy.resample% s5 õz Dñ *Ø $ð
|
Ø ò
|
Ø.<ð
|
Ø@Fñ
|
ð
|
rq c óh ddl m} || j g|¢| j | j d|¤S )a§
|
Return a rolling grouper, providing rolling functionality per group.
|
|
Parameters
|
----------
|
window : int, timedelta, str, offset, or BaseIndexer subclass
|
Size of the moving window.
|
|
If an integer, the fixed number of observations used for
|
each window.
|
|
If a timedelta, str, or offset, the time period of each window. Each
|
window will be a variable sized based on the observations included in
|
the time-period. This is only valid for datetimelike indexes.
|
To learn more about the offsets & frequency strings, please see `this link
|
<https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
|
|
If a BaseIndexer subclass, the window boundaries
|
based on the defined ``get_window_bounds`` method. Additional rolling
|
keyword arguments, namely ``min_periods``, ``center``, ``closed`` and
|
``step`` will be passed to ``get_window_bounds``.
|
|
min_periods : int, default None
|
Minimum number of observations in window required to have a value;
|
otherwise, result is ``np.nan``.
|
|
For a window that is specified by an offset,
|
``min_periods`` will default to 1.
|
|
For a window that is specified by an integer, ``min_periods`` will default
|
to the size of the window.
|
|
center : bool, default False
|
If False, set the window labels as the right edge of the window index.
|
|
If True, set the window labels as the center of the window index.
|
|
win_type : str, default None
|
If ``None``, all points are evenly weighted.
|
|
If a string, it must be a valid `scipy.signal window function
|
<https://docs.scipy.org/doc/scipy/reference/signal.windows.html#module-scipy.signal.windows>`__.
|
|
Certain Scipy window types require additional parameters to be passed
|
in the aggregation function. The additional parameters must match
|
the keywords specified in the Scipy window type method signature.
|
|
on : str, optional
|
For a DataFrame, a column label or Index level on which
|
to calculate the rolling window, rather than the DataFrame's index.
|
|
Provided integer column is ignored and excluded from result since
|
an integer index is not used to calculate the rolling window.
|
|
axis : int or str, default 0
|
If ``0`` or ``'index'``, roll across the rows.
|
|
If ``1`` or ``'columns'``, roll across the columns.
|
|
For `Series` this parameter is unused and defaults to 0.
|
|
closed : str, default None
|
If ``'right'``, the first point in the window is excluded from calculations.
|
|
If ``'left'``, the last point in the window is excluded from calculations.
|
|
If ``'both'``, no points in the window are excluded from calculations.
|
|
If ``'neither'``, the first and last points in the window are excluded
|
from calculations.
|
|
Default ``None`` (``'right'``).
|
|
method : str {'single', 'table'}, default 'single'
|
Execute the rolling operation per single column or row (``'single'``)
|
or over the entire object (``'table'``).
|
|
This argument is only implemented when specifying ``engine='numba'``
|
in the method call.
|
|
Returns
|
-------
|
pandas.api.typing.RollingGroupby
|
Return a new grouper with our rolling appended.
|
|
See Also
|
--------
|
Series.rolling : Calling object with Series data.
|
DataFrame.rolling : Calling object with DataFrames.
|
Series.groupby : Apply a function groupby to a Series.
|
DataFrame.groupby : Apply a function groupby.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({'A': [1, 1, 2, 2],
|
... 'B': [1, 2, 3, 4],
|
... 'C': [0.362, 0.227, 1.267, -0.562]})
|
>>> df
|
A B C
|
0 1 1 0.362
|
1 1 2 0.227
|
2 2 3 1.267
|
3 2 4 -0.562
|
|
>>> df.groupby('A').rolling(2).sum()
|
B C
|
A
|
1 0 NaN NaN
|
1 3.0 0.589
|
2 2 NaN NaN
|
3 7.0 0.705
|
|
>>> df.groupby('A').rolling(2, min_periods=1).sum()
|
B C
|
A
|
1 0 1.0 0.362
|
1 3.0 0.589
|
2 2 3.0 1.267
|
3 7.0 0.705
|
|
>>> df.groupby('A').rolling(2, on='B').sum()
|
B C
|
A
|
1 0 1 NaN
|
1 2 0.589
|
2 2 3 NaN
|
3 4 0.705
|
r )rd )r Ú _as_index)Úpandas.core.windowrd rz r r )rm ru rv rd s ro ÚrollingzGroupBy.rollingª sE õD 6á Ø × Ñ ð
|
à ñ
|
ð ]]Ømmñ
|
ð
|
ñ
|
ð
|
rq c óR ddl m} || j g|¢d| j i|¤S )z¯
|
Return an expanding grouper, providing expanding
|
functionality per group.
|
|
Returns
|
-------
|
pandas.api.typing.ExpandingGroupby
|
r )rb r )r¼ rb rz r )rm ru rv rb s ro Ú expandingzGroupBy.expanding6 s= õ 8á Ø × Ñ ð
|
à ò
|
ð ]]ð
|
ð ñ
|
ð
|
rq c óR ddl m} || j g|¢d| j i|¤S )z©
|
Return an ewm grouper, providing ewm functionality per group.
|
|
Returns
|
-------
|
pandas.api.typing.ExponentialMovingWindowGroupby
|
r )rc r )r¼ rc rz r )rm ru rv rc s ro Úewmz GroupBy.ewmK s> õ Fá-Ø × Ñ ð
|
à ò
|
ð ]]ð
|
ð ñ
|
ð
|
rq c ó0
|
|d} j j \ }}}t j |d¬« j t j
|
d¬« }|dk( r|ddd
}t t j ||| j ¬«
|
d
|
fd } j « }|j |« } j |« } j d
|
k( r'| j } j j | _ j j" | _ | S ) a
|
Shared function for `pad` and `backfill` to call Cython method.
|
|
Parameters
|
----------
|
direction : {'ffill', 'bfill'}
|
Direction passed to underlying Cython function. `bfill` will cause
|
values to be filled backwards. `ffill` and any other values will
|
default to a forward fill
|
limit : int, default None
|
Maximum number of consecutive values to fill. If `None`, this
|
method will convert to -1 prior to passing to Cython
|
|
Returns
|
-------
|
`Series` or `DataFrame` with filled values
|
|
See Also
|
--------
|
pad : Returns Series with minimum number of char in object.
|
backfill : Backward fill the missing values in the dataset.
|
Nr( Ú mergesort)rG Fr± Úbfill)r> Ú sorted_labelsÚlimitr c óþ t | « }| j dk( rOt j | j t j
|
¬« } ||¬« t j | |« S t | t j « rY| j }j j rt | j « }t j | j |¬« }n0t | « j | j | j ¬« }t! | « D ]a \ }}t j | j d t j
|
¬« } ||| ¬« t j ||« ||d d
f< c |S )Nrä r² )rÔ r? )r; r9 r½ rì r rú r> rä r» Úndarrayr³ r r r. r« Ú_emptyrL ) r: r? rë r³ rÔ ÚiÚ value_elementÚcol_funcrm s ro Úblk_funcz GroupBy._fill.<locals>.blk_func s ø Ü<DØ{{aÒ Ü (( 6§<¡<´r·w±wÔ?ÙW¨4Õ0Ü!×)Ñ)¨&°'Ó:Ð:ô
|
f¤b§j¡jÔ1Ø "LLEØ}}×3Ò3ä 8¸¿ ¹ Ó FÜ (( 6§<¡<°uÔ=Cô v,×-Ñ-¨f¯l©lÀ&Ç,Á,Ð-ÓOCä(1°&Ó(9ò KÑ$A}ä hh v§|¡|°A¡¼b¿g¹gÔ FGÙ ¨t°A©wÕ7Ü *× 2Ñ 2°=À'Ó JC1Ið Kð
|
|
rq rä rÍ )r r/ r½ r r¸ rú r Ú
|
libgroupbyÚgroup_fillna_indexerr rÎ ry rÐ r r# r rN r5 ) rm Ú directionrÆ rk rA rÅ rÍ Úmgrr r! rÌ s ` @ro Ú_fillz GroupBy._fill_ sí ù ð2 =ØEàMM×,Ñ, QÜ
|
|
3¨[Ô9×@Ñ@ÄÇÁÈuÐ@ÓU Ø Ò Ø )©$¨B¨$Ñ /MäÜ × +Ñ +ØØ'ØØ;;ô
|
ö ð< ×)Ñ)Ó+Ø))HÓ%à×*Ñ*¨7Ó3à 99>à iiGØ "hh× .Ñ .GOà Ørq c ó( | j d|¬« S )a0
|
Forward fill the values.
|
|
Parameters
|
----------
|
limit : int, optional
|
Limit of how many values to fill.
|
|
Returns
|
-------
|
Series or DataFrame
|
Object with missing values filled.
|
|
See Also
|
--------
|
Series.ffill: Returns Series with minimum number of char in object.
|
DataFrame.ffill: Object with missing values filled or None if inplace=True.
|
Series.fillna: Fill NaN values of a Series.
|
DataFrame.fillna: Fill NaN values of a DataFrame.
|
|
Examples
|
--------
|
|
For SeriesGroupBy:
|
|
>>> key = [0, 0, 1, 1]
|
>>> ser = pd.Series([np.nan, 2, 3, np.nan], index=key)
|
>>> ser
|
0 NaN
|
0 2.0
|
1 3.0
|
1 NaN
|
dtype: float64
|
>>> ser.groupby(level=0).ffill()
|
0 NaN
|
0 2.0
|
1 3.0
|
1 3.0
|
dtype: float64
|
|
For DataFrameGroupBy:
|
|
>>> df = pd.DataFrame(
|
... {
|
... "key": [0, 0, 1, 1, 1],
|
... "A": [np.nan, 2, np.nan, 3, np.nan],
|
... "B": [2, 3, np.nan, np.nan, np.nan],
|
... "C": [np.nan, np.nan, 2, np.nan, np.nan],
|
... }
|
... )
|
>>> df
|
key A B C
|
0 0 NaN 2.0 NaN
|
1 0 2.0 3.0 NaN
|
2 1 NaN NaN 2.0
|
3 1 3.0 NaN NaN
|
4 1 NaN NaN NaN
|
|
Propagate non-null values forward or backward within each group along columns.
|
|
>>> df.groupby("key").ffill()
|
A B C
|
0 NaN 2.0 NaN
|
1 2.0 3.0 NaN
|
2 NaN NaN 2.0
|
3 3.0 NaN 2.0
|
4 3.0 NaN 2.0
|
|
Propagate non-null values forward or backward within each group along rows.
|
|
>>> df.T.groupby(np.array([0, 0, 1, 1])).ffill().T
|
key A B C
|
0 0.0 0.0 2.0 2.0
|
1 0.0 2.0 3.0 3.0
|
2 1.0 1.0 NaN 2.0
|
3 1.0 3.0 NaN NaN
|
4 1.0 1.0 NaN NaN
|
|
Only replace the first NaN element within a group along rows.
|
|
>>> df.groupby("key").ffill(limit=1)
|
A B C
|
0 NaN 2.0 NaN
|
1 2.0 3.0 NaN
|
2 NaN NaN 2.0
|
3 3.0 NaN 2.0
|
4 3.0 NaN NaN
|
Úffill©rÆ ©rÒ ©rm rÆ s ro rÔ z GroupBy.ffill³ s ðv zz'¨zÓ/Ð/rq c ó( | j d|¬« S )a²
|
Backward fill the values.
|
|
Parameters
|
----------
|
limit : int, optional
|
Limit of how many values to fill.
|
|
Returns
|
-------
|
Series or DataFrame
|
Object with missing values filled.
|
|
See Also
|
--------
|
Series.bfill : Backward fill the missing values in the dataset.
|
DataFrame.bfill: Backward fill the missing values in the dataset.
|
Series.fillna: Fill NaN values of a Series.
|
DataFrame.fillna: Fill NaN values of a DataFrame.
|
|
Examples
|
--------
|
|
With Series:
|
|
>>> index = ['Falcon', 'Falcon', 'Parrot', 'Parrot', 'Parrot']
|
>>> s = pd.Series([None, 1, None, None, 3], index=index)
|
>>> s
|
Falcon NaN
|
Falcon 1.0
|
Parrot NaN
|
Parrot NaN
|
Parrot 3.0
|
dtype: float64
|
>>> s.groupby(level=0).bfill()
|
Falcon 1.0
|
Falcon 1.0
|
Parrot 3.0
|
Parrot 3.0
|
Parrot 3.0
|
dtype: float64
|
>>> s.groupby(level=0).bfill(limit=1)
|
Falcon 1.0
|
Falcon 1.0
|
Parrot NaN
|
Parrot 3.0
|
Parrot 3.0
|
dtype: float64
|
|
With DataFrame:
|
|
>>> df = pd.DataFrame({'A': [1, None, None, None, 4],
|
... 'B': [None, None, 5, None, 7]}, index=index)
|
>>> df
|
A B
|
Falcon 1.0 NaN
|
Falcon NaN NaN
|
Parrot NaN 5.0
|
Parrot NaN NaN
|
Parrot 4.0 7.0
|
>>> df.groupby(level=0).bfill()
|
A B
|
Falcon 1.0 NaN
|
Falcon NaN NaN
|
Parrot 4.0 5.0
|
Parrot 4.0 7.0
|
Parrot 4.0 7.0
|
>>> df.groupby(level=0).bfill(limit=1)
|
A B
|
Falcon 1.0 NaN
|
Falcon NaN NaN
|
Parrot NaN 5.0
|
Parrot 4.0 7.0
|
Parrot 4.0 7.0
|
rÄ rÕ rÖ r× s ro rÄ z GroupBy.bfill s ð\ zz'¨zÓ/Ð/rq c ó t | « S )aÞ
|
Take the nth row from each group if n is an int, otherwise a subset of rows.
|
|
Can be either a call or an index. dropna is not available with index notation.
|
Index notation accepts a comma separated list of integers and slices.
|
|
If dropna, will take the nth non-null row, dropna is either
|
'all' or 'any'; this is equivalent to calling dropna(how=dropna)
|
before the groupby.
|
|
Parameters
|
----------
|
n : int, slice or list of ints and slices
|
A single nth value for the row or a list of nth values or slices.
|
|
.. versionchanged:: 1.4.0
|
Added slice and lists containing slices.
|
Added index notation.
|
|
dropna : {'any', 'all', None}, default None
|
Apply the specified dropna operation before counting which row is
|
the nth row. Only supported if n is an int.
|
|
Returns
|
-------
|
Series or DataFrame
|
N-th value within each group.
|
%(see_also)s
|
Examples
|
--------
|
|
>>> df = pd.DataFrame({'A': [1, 1, 2, 1, 2],
|
... 'B': [np.nan, 2, 3, 4, 5]}, columns=['A', 'B'])
|
>>> g = df.groupby('A')
|
>>> g.nth(0)
|
A B
|
0 1 NaN
|
2 2 3.0
|
>>> g.nth(1)
|
A B
|
1 1 2.0
|
4 2 5.0
|
>>> g.nth(-1)
|
A B
|
3 1 4.0
|
4 2 5.0
|
>>> g.nth([0, 1])
|
A B
|
0 1 NaN
|
1 1 2.0
|
2 2 3.0
|
4 2 5.0
|
>>> g.nth(slice(None, -1))
|
A B
|
0 1 NaN
|
1 1 2.0
|
2 2 3.0
|
|
Index notation may also be used
|
|
>>> g.nth[0, 1]
|
A B
|
0 1 NaN
|
1 1 2.0
|
2 2 3.0
|
4 2 5.0
|
>>> g.nth[:-1]
|
A B
|
0 1 NaN
|
1 1 2.0
|
2 2 3.0
|
|
Specifying `dropna` allows ignoring ``NaN`` values
|
|
>>> g.nth(0, dropna='any')
|
A B
|
1 1 2.0
|
2 2 3.0
|
|
When the specified ``n`` is larger than any of the groups, an
|
empty DataFrame is returned
|
|
>>> g.nth(3, dropna='any')
|
Empty DataFrame
|
Columns: [A, B]
|
Index: []
|
)rU r¡ s ro Únthz GroupBy.nth` s ôx " $Ó'Ð'rq c óº |sF| j |« }| j j \ }}}||dk7 z }| j |« }|S t |« s t d« |dvrt d| d« t t |« }| j j || j ¬« }t |« t | j « k( r | j }n| j j } | j j | j |j « }| j j r-|dk( }
|
t! j" |
|
t$ |« } t' | d¬« }| j d k( r3|j( j+ || j, | j. ¬
|
« } n(|j+ || j, | j. ¬
|
« } | j1 |« S ) Nr( z4dropna option only supported for an integer argumentrÄ z_For a DataFrame or Series groupby.nth, dropna must be either None, 'any' or 'all', (was passed z).)r¦ r ÚInt64r² rä )r r )Ú"_make_mask_from_positional_indexerr r/ Ú_mask_selected_objr2 rÍ r rô rz r r r Ú
|
codes_infoÚisinr5 r r½ rï r rW r# rn r r rÚ ) rm rÄ r r? rk rA rÔ Údroppedr r Únullsr: Úgrbs ro Ú_nthz GroupBy._nth¾ s ñ
|
Ø×:Ñ:¸1Ó=Dà ×0Ñ0ICAð 3 "9Ñ%Dà×)Ñ)¨$Ó/CØJô !}Ü Ð SÓTÐ Tà Ñ 'ä ð à %h bð*óð ô aLØ×$Ñ$×+Ñ+°¸T¿Y¹YÐ+ÓGô w<3t× 1Ñ 1Ó2Ò 2àmmGð
|
==×%Ñ%DØmm×.Ñ.¨t¯y©y¸¿ ¹ Ó/GÑHGØ}}×+Ò+à 2 ô %¬¨WÓ5Ü ¨gÔ6à 99>Ø))×#Ñ# G°d·m±mÈ$Ï)É)Ð#ÓTCà// '°D·M±MÈÏ É /ÓRCØwwqzÐrq c óÀ j |d¬« } j |« } j dk( rH j j |j
|
j ¬« }|j j
|
}n3 j j | j ¬« }|j }t j |j |j « \ }} d fd d fd t j |t j ¬« }
|
|
|
} t |« r(t j |gt j ¬« }
|
d} j j \ } } t! |
|
« t# t$ j& | |
|
|| ¬ « dfd
|
}|j( j+ |« } j |« } j- || ¬ « S )a
|
Return group values at the given quantile, a la numpy.percentile.
|
|
Parameters
|
----------
|
q : float or array-like, default 0.5 (50% quantile)
|
Value(s) between 0 and 1 providing the quantile(s) to compute.
|
interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}
|
Method to use when the desired quantile falls between two points.
|
numeric_only : bool, default False
|
Include only `float`, `int` or `boolean` data.
|
|
.. versionadded:: 1.5.0
|
|
.. versionchanged:: 2.0.0
|
|
numeric_only now defaults to ``False``.
|
|
Returns
|
-------
|
Series or DataFrame
|
Return type determined by caller of GroupBy object.
|
|
See Also
|
--------
|
Series.quantile : Similar method for Series.
|
DataFrame.quantile : Similar method for DataFrame.
|
numpy.percentile : NumPy method to compute qth percentile.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame([
|
... ['a', 1], ['a', 2], ['a', 3],
|
... ['b', 1], ['b', 3], ['b', 5]
|
... ], columns=['key', 'val'])
|
>>> df.groupby('key').quantile()
|
val
|
key
|
a 2.0
|
b 3.0
|
ÚquantilerÀ rä ræ c ó t | j t « st | j « rt d| j d« d }t | t
|
« rJt | j « r5| j t t j ¬« }| j }||fS t | j « r_t | t « r&| j t t j ¬« }n| }t j t j « }||fS t | j « r9t | t « r)| j t t j ¬« }||fS t | j « rTt j dt# « j$ dt& t) « ¬« t j* | « }||fS t- | j « r| j }| |fS t | t « rat/ | j « rLt j t j0 « }| j t t j ¬« }||fS t j* | « }||fS )Nzdtype 'z'' does not support operation 'quantile')r³ r zAllowing bool dtype in z.quantile is deprecated and will raise in a future version, matching the Series/DataFrame behavior. Cast to uint8 dtype before calling quantile instead.rå )r» r³ rI r6 r rC r5 rg Úfloatr½ rø r3 rE ré r/ r© rª r« rx r¬ r, Úasarrayr9 r0 rù )ÚvalsÚ inferencerÔ rm s ro Ú pre_processorz'GroupBy.quantile.<locals>.pre_processor3 sò ø Ü$**¤kÔ2´oÀdÇjÁjÔ6QÜ Ø djj\Ð)PÐQóð ð *.IÜ$¤Ô0Ô5EÀdÇjÁjÔ5QØmm¬%¼"¿&¹&mÓAØ JJ ðF >Ð !ôE " $§*¡*Ô-Ü d¤NÔ3Ø --¬e¼b¿f¹f-ÓECà CÜ HH¤R§X¡XÓ . ð: >Ð !ô9 tzzÔ*¬z¸$ÄÔ/OØmm¬%¼"¿&¹&mÓAð6 >Ð !ô5 tzzÔ*ä Ø-¬d°4«j×.AÑ.AÐ-Bð C0ð 0ô "Ü /Ó 1õ ô jj Ó&ð >Ð !ô % T§Z¡ZÔ0Ø JJ ð YÐ&ÜD¤.Ô1´nÀTÇZÁZÔ6PÜ HH¤R§Z¡ZÓ 0 Ømm¬%¼"¿&¹&mÓAð >Ð !ô jj Ó&à >Ð !rq c óf |r t |t « r|J dv rt |« s t | |« S t j
|
« 5 t j dt ¬« t |« | j |j « |« cd d d « S t |« rdv s}t |« rE| j d« j |j j « } |j! | « S t |t" j « sJ | j |« S | S # 1 sw Y | S xY w)N> ÚlinearÚmidpointÚignore)r§ Úi8)r» rC r0 rF r© Úcatch_warningsÚfilterwarningsÚRuntimeWarningr« r¸ Ú numpy_dtyper3 r9 ÚviewÚ_ndarrayr³ Ú_from_backing_datar½ )rê rë Ú result_maskÚ orig_valsÚ interpolations ro Úpost_processorz(GroupBy.quantile.<locals>.post_processora s* ø ò ä i¬ Ô9Ø&Ð2Ð2Ð2à$Ð(>Ñ>Ä~Ø!ôHô -¨T°;Ó ?Ð?ô
|
&× 4Ñ 4Ó 6ñ ä $× 3Ñ 3°HÄ~Õ VØ#2¤4¨ £?Ø $§ ¡ Ø$-×$9Ñ$9ó!"ð !,ó $ ÷ ñ ô % YÔ/Ø%Ð)?Ñ?ä*¨9Ô5ð ${{¨4Ó 0× 5Ñ 5Ø %× .Ñ .× 4Ñ 4ó ð
|
)× ;Ñ ;Ø ó ð ô & i´·±Ô:Ð:Ð:Ø ;; yÓ1Ð1àK÷; ð: Kús ÁAD&Ä&D0r² N)r> rZ rû rr rs c óÔ | }t | t « r4| j }t j ft j
|
¬« }n t | « }d }t | j « } | « \ }}d}|j dk( r|j d }t j | ft j ¬« }|r|j d« }|j dk( r
|
|d ||||¬« n&t |« D ] }
|
|| || || d |¬« |j dk( r%|j d« }|'|j d« }n|j! | z « } ||||« S )Nr² rä rv r rñ )r: r? rù Úis_datetimelikeÚK)r» rC Ú_maskr½ r r r; r9 r³ r9 r rì rù rö r- r r )r: rú r? rù rþ rê rë ÚncolsrÔ rÊ râ r¯ Únqsrü rì s ro rÍ z"GroupBy.quantile.<locals>.blk_func¥ sX ø Ø IÜ&¤/Ô2Ø ||Ü hh¨° ~¼R¿X¹XÔ F äF|Ø " ä 1°&·,±,Ó ?Oá +¨FÓ 3OD)àEØyyA~Ø
|
|
1 ä((E 7¨CÐ0¼¿
|
¹
|
ÔCCá Øyy àyyA~áØFØ Ø Ø +Ø$3ö ô u ò AÙØAØ # AwØ ! !WØ$(Ø(7ö ðð yyA~Øii nØ Ð*Ø"-×"3Ñ"3°CÓ"8Kàkk %¨°3© Ó7á! # y°+¸yÓIÐ Irq rY )rê r r
z"tuple[np.ndarray, DtypeObj | None])
|
rê ú
|
np.ndarrayrë zDtypeObj | Nonerù znp.ndarray | Nonerú r r
r rÍ )rÎ rÐ r r Ú _get_splitterr# Ú _sorted_datar rj Ú_slabelsr¯ r½ rê rù r7 r/ r r rÎ Úgroup_quantilerx rÏ r_ )rm Úqrû r¨ rÑ r ÚsplitterÚsdatarr rs rZ Úpass_qsrk rA rÍ r r^ râ r¯ r rü rì s ` ` @@@@@ro ræ zGroupBy.quantileø s² þ ð` ×)Ñ)°|È*Ð)ÓUØ×&Ñ& sÓ+Ø 99>Ø}}×2Ñ2°3·5±5¸t¿y¹yÐ2ÓIHØ ×)Ñ)×+Ñ+Eà}}×2Ñ2°3¸T¿Y¹YÐ2ÓGHØ ×)Ñ)Eä×*Ñ*¨8×+<Ñ+<¸h×>NÑ>NÓO õ, "ð\0 Ø ð0 à&ð0 ð +ð0 ð !ð 0 ð
|
õ 0 ôd XXarzzÔ *Ø%'Ü Q<Ü1#¤R§Z¡ZÔ0BØGà --×2Ñ2QÜ"gäÜ × %Ñ %ØØØ'ØØô
|
÷0 Jñ 0 Jðd **×+Ñ+¨HÓ5à×&Ñ& wÓ/Ø×+Ñ+¨C°GÐ+Ó<Ð<rq c ó | j }|j | j « }| j j d }| j j
|
r9t j |dk( t j |« }t j }nt j }t d | j j D « « rt |d¬« dz
|
}| j |||¬« }|s| j dz
|
|z
|
}|S )a
|
Number each group from 0 to the number of groups - 1.
|
|
This is the enumerative complement of cumcount. Note that the
|
numbers given to the groups match the order in which the groups
|
would be seen when iterating over the groupby object, not the
|
order they are first observed.
|
|
Groups with missing keys (where `pd.isna()` is True) will be labeled with `NaN`
|
and will be skipped from the count.
|
|
Parameters
|
----------
|
ascending : bool, default True
|
If False, number in reverse, from number of group - 1 to 0.
|
|
Returns
|
-------
|
Series
|
Unique numbers for each group.
|
|
See Also
|
--------
|
.cumcount : Number the rows in each group.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({"color": ["red", None, "red", "blue", "blue", "red"]})
|
>>> df
|
color
|
0 red
|
1 None
|
2 red
|
3 blue
|
4 blue
|
5 red
|
>>> df.groupby("color").ngroup()
|
0 1.0
|
1 NaN
|
2 1.0
|
3 0.0
|
4 0.0
|
5 1.0
|
dtype: float64
|
>>> df.groupby("color", dropna=False).ngroup()
|
0 1
|
1 2
|
2 1
|
3 0
|
4 0
|
5 1
|
dtype: int64
|
>>> df.groupby("color", dropna=False).ngroup(ascending=False)
|
0 1
|
1 0
|
2 1
|
3 2
|
4 2
|
5 1
|
dtype: int64
|
r r( c 3 ó4 K | ] }|j y wrk r r s ro rÅ z!GroupBy.ngroup.<locals>.<genexpr>' s è ø ÒL¨Dt×'Õ'ÑLùr Údense)Ú ties_methodrä r² )rÚ r. r r r/ r r½ rï rø rù ré r r r r r¯ )rm rü r r5 Úcomp_idsr³ rò s ro ÚngroupzGroupBy.ngroupÜ sÌ ð@ ×'Ñ'Ø diiÓ(Ø==×+Ñ+¨AÑ.ð ==× 'Ò 'Üxx ¨B¡´·±¸ÓAHÜJJEäHHEä ÑL°D·M±M×4KÑ4KÔLÔ Lä x°WÔ=ÀÑAHà×)Ñ)¨(°EÀÐ)ÓGÙØ\\ AÑ%¨Ñ.FØ rq c ó | j j | j « }| j |¬« }| j ||« S )a
|
Number each item in each group from 0 to the length of that group - 1.
|
|
Essentially this is equivalent to
|
|
.. code-block:: python
|
|
self.apply(lambda x: pd.Series(np.arange(len(x)), x.index))
|
|
Parameters
|
----------
|
ascending : bool, default True
|
If False, number in reverse, from length of group - 1 to 0.
|
|
Returns
|
-------
|
Series
|
Sequence number of each element within each group.
|
|
See Also
|
--------
|
.ngroup : Number the groups themselves.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame([['a'], ['a'], ['a'], ['b'], ['b'], ['a']],
|
... columns=['A'])
|
>>> df
|
A
|
0 a
|
1 a
|
2 a
|
3 b
|
4 b
|
5 a
|
>>> df.groupby('A').cumcount()
|
0 0
|
1 1
|
2 2
|
3 0
|
4 1
|
5 3
|
dtype: int64
|
>>> df.groupby('A').cumcount(ascending=False)
|
0 3
|
1 2
|
2 1
|
3 1
|
4 0
|
5 0
|
dtype: int64
|
)rü )rÚ r. r r r )rm rü r5 Ú cumcountss ro ÚcumcountzGroupBy.cumcount0 sE ðn ×)Ñ)×3Ñ3°D·I±IÓ>Ø×(Ñ(°9Ð(Ó= Ø×'Ñ'¨ °5Ó9Ð9rq ÚaverageÚkeepc ód |dvr d}t |« t j ur.| j j « | j d« nd||||d dk7 r: j d« d< fd}| j || j d ¬
|
« }|S | j d d d ¤S )a
|
Provide the rank of values within each group.
|
|
Parameters
|
----------
|
method : {'average', 'min', 'max', 'first', 'dense'}, default 'average'
|
* average: average rank of group.
|
* min: lowest rank in group.
|
* max: highest rank in group.
|
* first: ranks assigned in order they appear in the array.
|
* dense: like 'min', but rank always increases by 1 between groups.
|
ascending : bool, default True
|
False for ranks by high (1) to low (N).
|
na_option : {'keep', 'top', 'bottom'}, default 'keep'
|
* keep: leave NA values where they are.
|
* top: smallest rank if ascending.
|
* bottom: smallest rank if descending.
|
pct : bool, default False
|
Compute percentage rank of data within each group.
|
axis : int, default 0
|
The axis of the object over which to compute the rank.
|
|
.. deprecated:: 2.1.0
|
For axis=1, operate on the underlying object instead. Otherwise
|
the axis keyword is not necessary.
|
|
Returns
|
-------
|
DataFrame with ranking of values within each group
|
%(see_also)s
|
Examples
|
--------
|
>>> df = pd.DataFrame(
|
... {
|
... "group": ["a", "a", "a", "a", "a", "b", "b", "b", "b", "b"],
|
... "value": [2, 4, 2, 3, 5, 1, 2, 4, 1, 5],
|
... }
|
... )
|
>>> df
|
group value
|
0 a 2
|
1 a 4
|
2 a 2
|
3 a 3
|
4 a 5
|
5 b 1
|
6 b 2
|
7 b 4
|
8 b 1
|
9 b 5
|
>>> for method in ['average', 'min', 'max', 'dense', 'first']:
|
... df[f'{method}_rank'] = df.groupby('group')['value'].rank(method)
|
>>> df
|
group value average_rank min_rank max_rank dense_rank first_rank
|
0 a 2 1.5 1.0 2.0 1.0 1.0
|
1 a 4 4.0 4.0 4.0 3.0 4.0
|
2 a 2 1.5 1.0 2.0 1.0 2.0
|
3 a 3 3.0 3.0 3.0 2.0 3.0
|
4 a 5 5.0 5.0 5.0 4.0 5.0
|
5 b 1 1.5 1.0 2.0 1.0 1.0
|
6 b 2 3.0 3.0 3.0 2.0 3.0
|
7 b 4 4.0 4.0 4.0 3.0 4.0
|
8 b 1 1.5 1.0 2.0 1.0 2.0
|
9 b 5 5.0 5.0 5.0 4.0 5.0
|
> Útopr Úbottomz3na_option must be one of 'keep', 'top', or 'bottom'Úrankr )r rü Ú na_optionÚpctr r« c ó. | j ddd¤S )NF)r r¨ r ©r ©r r rv s ro r· z GroupBy.rank.<locals>.<lambda>Ê s ø &!&&ÐI d¸ÑIÀ&ÑI rq T©r F)r¨ r r )
|
rÍ r r r r r Úpopry rz rÖ )
|
rm r« rü r r r rÓ rw rò rv s
|
` @ro r z GroupBy.rankk sß ù ðX Ð 5Ñ 5ØGCÜ S/Ð !à s~~Ñ %Ø88×,Ñ,¨TÓ2DØ × Ñ vÕ .àDð "Ø"Ø"Øñ
|
ð 19à %zz¨-Ó 8F8Ñ ÜIAØ×/Ñ/Ø4×%Ñ%°Dð 0ó Fð Mà%t×%Ñ%Ø ð
|
à Øñ
|
ð ñ
|
ð
|
rq c ó4 t j d|ddg« t j ur.| j j « | j d« nddk7 r$fd}| j || j d¬« S | j di ¤S ) aê
|
Cumulative product for each group.
|
|
Returns
|
-------
|
Series or DataFrame
|
%(see_also)s
|
Examples
|
--------
|
For SeriesGroupBy:
|
|
>>> lst = ['a', 'a', 'b']
|
>>> ser = pd.Series([6, 2, 0], index=lst)
|
>>> ser
|
a 6
|
a 2
|
b 0
|
dtype: int64
|
>>> ser.groupby(level=0).cumprod()
|
a 6
|
a 12
|
b 0
|
dtype: int64
|
|
For DataFrameGroupBy:
|
|
>>> data = [[1, 8, 2], [1, 2, 5], [2, 6, 9]]
|
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
|
... index=["cow", "horse", "bull"])
|
>>> df
|
a b c
|
cow 1 8 2
|
horse 1 2 5
|
bull 2 6 9
|
>>> df.groupby("a").groups
|
{1: ['cow', 'horse'], 2: ['bull']}
|
>>> df.groupby("a").cumprod()
|
b c
|
cow 8 2
|
horse 16 10
|
bull 6 9
|
Úcumprodr¨ r r c ó, | j ddi¤S ©Nr r ©r# r s ro r· z!GroupBy.cumprod.<locals>.<lambda> s ø )!))Ñ8¨Ð8°Ñ8 rq Tr r& ©
|
ÚnvÚvalidate_groupby_funcr r r r r ry rz rÖ ©rm r ru rv rw s ` ` ro r# zGroupBy.cumprod× s ù ô` × Ñ ¨D°&¸>È8Ð:TÔUØ s~~Ñ %Ø88×,Ñ,¨TÓ2DØ × Ñ yÕ 1àDà 19Ü8AØ×-Ñ-¨a°×1CÑ1CÐRVÐ-ÓWÐ Wà%t×%Ñ%Ñ:°6Ñ:Ð:rq c ó4 t j d|ddg« t j ur.| j j « | j d« nddk7 r$fd}| j || j d¬« S | j di ¤S ) aø
|
Cumulative sum for each group.
|
|
Returns
|
-------
|
Series or DataFrame
|
%(see_also)s
|
Examples
|
--------
|
For SeriesGroupBy:
|
|
>>> lst = ['a', 'a', 'b']
|
>>> ser = pd.Series([6, 2, 0], index=lst)
|
>>> ser
|
a 6
|
a 2
|
b 0
|
dtype: int64
|
>>> ser.groupby(level=0).cumsum()
|
a 6
|
a 8
|
b 0
|
dtype: int64
|
|
For DataFrameGroupBy:
|
|
>>> data = [[1, 8, 2], [1, 2, 5], [2, 6, 9]]
|
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
|
... index=["fox", "gorilla", "lion"])
|
>>> df
|
a b c
|
fox 1 8 2
|
gorilla 1 2 5
|
lion 2 6 9
|
>>> df.groupby("a").groups
|
{1: ['fox', 'gorilla'], 2: ['lion']}
|
>>> df.groupby("a").cumsum()
|
b c
|
fox 8 2
|
gorilla 10 7
|
lion 6 9
|
rö r¨ r r c ó, | j ddi¤S r% ©rö r s ro r· z GroupBy.cumsum.<locals>.<lambda>L s ø (!((Ñ7¨Ð7°Ñ7 rq Tr r- r' r* s ` ` ro rö zGroupBy.cumsum s ù ô` × Ñ ¨4°¸.È(Ð9SÔTØ s~~Ñ %Ø88×,Ñ,¨TÓ2DØ × Ñ xÕ 0àDà 19Ü7AØ×-Ñ-¨a°×1CÑ1CÐRVÐ-ÓWÐ Wà%t×%Ñ%Ñ9°&Ñ9Ð9rq c óL |j dd« }t j ur.| j j « | j d« nddk7 r7fd}| j }|r|j « }| j ||d¬« S | j d||¬« S )a`
|
Cumulative min for each group.
|
|
Returns
|
-------
|
Series or DataFrame
|
%(see_also)s
|
Examples
|
--------
|
For SeriesGroupBy:
|
|
>>> lst = ['a', 'a', 'a', 'b', 'b', 'b']
|
>>> ser = pd.Series([1, 6, 2, 3, 0, 4], index=lst)
|
>>> ser
|
a 1
|
a 6
|
a 2
|
b 3
|
b 0
|
b 4
|
dtype: int64
|
>>> ser.groupby(level=0).cummin()
|
a 1
|
a 1
|
a 1
|
b 3
|
b 0
|
b 0
|
dtype: int64
|
|
For DataFrameGroupBy:
|
|
>>> data = [[1, 0, 2], [1, 1, 5], [6, 6, 9]]
|
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
|
... index=["snake", "rabbit", "turtle"])
|
>>> df
|
a b c
|
snake 1 0 2
|
rabbit 1 1 5
|
turtle 6 6 9
|
>>> df.groupby("a").groups
|
{1: ['snake', 'rabbit'], 6: ['turtle']}
|
>>> df.groupby("a").cummin()
|
b c
|
snake 0 2
|
rabbit 0 2
|
turtle 6 9
|
r TÚcumminr c óD t j j | « S rk )r½ ÚminimumÚ
|
accumulate©r r s ro r· z GroupBy.cummin.<locals>.<lambda> ó ø "**×/Ñ/°°4Ó8 rq r ©r¨ r ©
|
rÏ r r r r r rz Ú_get_numeric_datary rÖ ©rm r r¨ rv r rw r s ` ro r/ zGroupBy.cumminQ óª ø ðr H dÓ+Ø s~~Ñ %Ø88×,Ñ,¨TÓ2DØ × Ñ xÕ 0àDà 19Û8AØ×$Ñ$CÙØ×+Ñ+Ó-Ø×-Ñ-¨a°À4Ð-ÓHÐ Hà×%Ñ%Ø <¸ð &ó
|
ð
|
rq c óL |j dd« }t j ur.| j j « | j d« nddk7 r7fd}| j }|r|j « }| j ||d¬« S | j d||¬« S )aV
|
Cumulative max for each group.
|
|
Returns
|
-------
|
Series or DataFrame
|
%(see_also)s
|
Examples
|
--------
|
For SeriesGroupBy:
|
|
>>> lst = ['a', 'a', 'a', 'b', 'b', 'b']
|
>>> ser = pd.Series([1, 6, 2, 3, 1, 4], index=lst)
|
>>> ser
|
a 1
|
a 6
|
a 2
|
b 3
|
b 1
|
b 4
|
dtype: int64
|
>>> ser.groupby(level=0).cummax()
|
a 1
|
a 6
|
a 6
|
b 3
|
b 3
|
b 4
|
dtype: int64
|
|
For DataFrameGroupBy:
|
|
>>> data = [[1, 8, 2], [1, 1, 0], [2, 6, 9]]
|
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
|
... index=["cow", "horse", "bull"])
|
>>> df
|
a b c
|
cow 1 8 2
|
horse 1 1 0
|
bull 2 6 9
|
>>> df.groupby("a").groups
|
{1: ['cow', 'horse'], 2: ['bull']}
|
>>> df.groupby("a").cummax()
|
b c
|
cow 8 2
|
horse 8 2
|
bull 6 9
|
r TÚcummaxr c óD t j j | « S rk )r½ Úmaximumr2 r3 s ro r· z GroupBy.cummax.<locals>.<lambda>Ý r4 rq r r5 r6 r8 s ` ro r; zGroupBy.cummax r9 rq c ó0 t j ur.| j j « | j d« ndt |« rBdk( r t d« t t |« }t |« dk( r t d« ddl
|
m } d}nFt |« st d| d t |« d
|
« |r t d « t t |« g}d }g }|D ] t « st d d t « d
|
« t t « dk7 r'fd} | j! | | j" d¬« }
|
n¹t j u rd | j$ j& \ } } } t) j* t | « t( j, ¬« }t/ j0 || | « | j2 }|j5 | j6 |j8 | j6 |fid¬« }
|
|rKt; |
|
t< « r t t> |
|
jA « « }
|
|
|
jC |r| d nd « }
|
|jE t tF t< tH f |
|
« « t |« dk( r|d S |d¬« S )aY
|
Shift each group by periods observations.
|
|
If freq is passed, the index will be increased using the periods and the freq.
|
|
Parameters
|
----------
|
periods : int | Sequence[int], default 1
|
Number of periods to shift. If a list of values, shift each group by
|
each period.
|
freq : str, optional
|
Frequency string.
|
axis : axis to shift, default 0
|
Shift direction.
|
|
.. deprecated:: 2.1.0
|
For axis=1, operate on the underlying object instead. Otherwise
|
the axis keyword is not necessary.
|
|
fill_value : optional
|
The scalar value to use for newly introduced missing values.
|
|
.. versionchanged:: 2.1.0
|
Will raise a ``ValueError`` if ``freq`` is provided too.
|
|
suffix : str, optional
|
A string to add to each shifted column if there are multiple periods.
|
Ignored otherwise.
|
|
Returns
|
-------
|
Series or DataFrame
|
Object shifted within each group.
|
|
See Also
|
--------
|
Index.shift : Shift values of Index.
|
|
Examples
|
--------
|
|
For SeriesGroupBy:
|
|
>>> lst = ['a', 'a', 'b', 'b']
|
>>> ser = pd.Series([1, 2, 3, 4], index=lst)
|
>>> ser
|
a 1
|
a 2
|
b 3
|
b 4
|
dtype: int64
|
>>> ser.groupby(level=0).shift(1)
|
a NaN
|
a 1.0
|
b NaN
|
b 3.0
|
dtype: float64
|
|
For DataFrameGroupBy:
|
|
>>> data = [[1, 2, 3], [1, 5, 6], [2, 5, 8], [2, 6, 9]]
|
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
|
... index=["tuna", "salmon", "catfish", "goldfish"])
|
>>> df
|
a b c
|
tuna 1 2 3
|
salmon 1 5 6
|
catfish 2 5 8
|
goldfish 2 6 9
|
>>> df.groupby("a").shift(1)
|
b c
|
tuna NaN NaN
|
salmon 2.0 3.0
|
catfish NaN NaN
|
goldfish 5.0 8.0
|
Úshiftr rä z:If `periods` contains multiple shifts, `axis` cannot be 1.z0If `periods` is an iterable, it cannot be empty.r% Tz Periods must be integer, but z is r z/Cannot specify `suffix` if `periods` is an int.FNc ó, | j « S rk )r? )r r r ÚfreqÚperiods ro r· z GroupBy.shift.<locals>.<lambda>` s ø aggØD $¨
|
ó rq r r² )r rã rA ræ )%r r r r r r4 rÍ r r r r+ r& r2 r r« rô ry rz r r/ r½ r ré rÎ Úgroup_shift_indexerrÚ rå r r1 r» r\ r rM Ú
|
add_suffixÚappendr rN )rm ÚperiodsrA r r Úsuffixr& rD Úshifted_dataframesrw Úshiftedrk rA r¯ Ú res_indexerr rB s ``` @ro r? z GroupBy.shiftç s û ðl s~~Ñ %Ø88×,Ñ,¨TÓ2DØ × Ñ wÕ /àDä Ô ØqyÜ ØPóð ô 8 WÓ-GÜ7|qÒ Ü Ð!SÓTÐTÝ 9à Jä gÔ&Ü Ø3°G°9¸DÄÀgà ÀÈqÐQóð ñ Ü Ð!RÓSÐSÜC Ó)Ð*GØ Jà ÐØ ó # OFÜ fÔ%Ü Ø3°F°8¸4ÄÀVà ¸~ÈQÐOóð ô #vÓ&FØÐ 4¨1¢9öð ×4Ñ4Øt×)Ñ)¸ð 5ó 𠤧 ¡ Ñ/Ø!%JØ"&§-¡-×":Ñ":QÜ hh¤s¨3£x´r·x±xÔ @ ä×.Ñ.¨{¸CÀÈ&ÔQà×/Ñ/à ×4Ñ4ØYY §¡¨$¯)©)Ñ!4°kÐ BÐCØ )Ø #ð 5ó ñ Ü g¤vÔ.Ü "¤8¨W×-=Ñ-=Ó-?Ó @GØ!×,Ñ,Ù,2vha xÑ(¸!¸F¸8¸ óð × %Ñ %¤d¬5´¼Ð1BÑ+CÀWÓ&MÖ NðG# OôN Ð%Ó&¨!Ò+ð qÑ !ð
|
ñ Ð*°Ô3ð
|
rq c ó@ t j ur.| j j « | j d« nddk7 r| j fd« S | j }| j ¬« }ddg}|j dk( r$|j |v r|j d« }||z
|
S |j j « D cg c] \ }}||v s | }}}t |« r |j |D ci c] }|d c}« }||z
|
S c c}}w c c}w ) a?
|
First discrete difference of element.
|
|
Calculates the difference of each element compared with another
|
element in the group (default is element in previous row).
|
|
Parameters
|
----------
|
periods : int, default 1
|
Periods to shift for calculating difference, accepts negative values.
|
axis : axis to shift, default 0
|
Take difference over rows (0) or columns (1).
|
|
.. deprecated:: 2.1.0
|
For axis=1, operate on the underlying object instead. Otherwise
|
the axis keyword is not necessary.
|
|
Returns
|
-------
|
Series or DataFrame
|
First differences.
|
%(see_also)s
|
Examples
|
--------
|
For SeriesGroupBy:
|
|
>>> lst = ['a', 'a', 'a', 'b', 'b', 'b']
|
>>> ser = pd.Series([7, 2, 8, 4, 3, 3], index=lst)
|
>>> ser
|
a 7
|
a 2
|
a 8
|
b 4
|
b 3
|
b 3
|
dtype: int64
|
>>> ser.groupby(level=0).diff()
|
a NaN
|
a -5.0
|
a 6.0
|
b NaN
|
b -1.0
|
b 0.0
|
dtype: float64
|
|
For DataFrameGroupBy:
|
|
>>> data = {'a': [1, 3, 5, 7, 7, 8, 3], 'b': [1, 4, 8, 4, 4, 2, 1]}
|
>>> df = pd.DataFrame(data, index=['dog', 'dog', 'dog',
|
... 'mouse', 'mouse', 'mouse', 'mouse'])
|
>>> df
|
a b
|
dog 1 1
|
dog 3 4
|
dog 5 8
|
mouse 7 4
|
mouse 7 4
|
mouse 8 2
|
mouse 3 1
|
>>> df.groupby(level=0).diff()
|
a b
|
dog NaN NaN
|
dog 2.0 3.0
|
dog 2.0 4.0
|
mouse NaN NaN
|
mouse 0.0 0.0
|
mouse 1.0 -2.0
|
mouse -5.0 -1.0
|
rô r c ó* | j ¬« S )N)rF r )rô )r r rF s ro r· z GroupBy.diff.<locals>.<lambda>Ö s ø ¨¯©°wÀT¨Ó(J rq )rF Úint8Úint16rä Úfloat32)r r r r r ry rÚ r? r9 r³ r¸ ÚdtypesÚitemsr ) rm rF r r rI Ú dtypes_to_f32Úcr³ Ú to_coerces `` ro rô z GroupBy.diff s ù ðV s~~Ñ %Ø88×,Ñ,¨TÓ2DØ × Ñ vÕ .àDà 19Ø::Ô JÓKÐ Kà×'Ñ'Ø** W*Ó-ð Ð) Ø 88q=ØyyMÑ)Ø!..¨Ó3ð W}Ð ð ,/¯:©:×+;Ñ+;Ó+=×Xxq %ÀÈ-ÒAWÐXIÑXÜ9~Ø!..À Ö)J¸1¨!¨Y©,Ò)JÓKàW}Ð ùó Yùâ)Js à Dà DÃ?
|
Dc óR t j dfvst j ur;t j dt | « j
|
dt t « ¬« t j u rat j u rMt d | D « « r;t j dt | « j
|
dt t « ¬« dt j u rdt j ur.| j j « | j d « nd
|
d
|
k7 r'fd }| j || j d ¬ « S dd
|
t | « ¬« }| j d
|
k( r2|j! | j" j$ | j& ¬« }n;|j( j! | j" j$ | j& ¬« }|j+ ¬« } | j dk( r | j( } || z dz
|
S )a
|
Calculate pct_change of each value to previous entry in group.
|
|
Returns
|
-------
|
Series or DataFrame
|
Percentage changes within each group.
|
%(see_also)s
|
Examples
|
--------
|
|
For SeriesGroupBy:
|
|
>>> lst = ['a', 'a', 'b', 'b']
|
>>> ser = pd.Series([1, 2, 3, 4], index=lst)
|
>>> ser
|
a 1
|
a 2
|
b 3
|
b 4
|
dtype: int64
|
>>> ser.groupby(level=0).pct_change()
|
a NaN
|
a 1.000000
|
b NaN
|
b 0.333333
|
dtype: float64
|
|
For DataFrameGroupBy:
|
|
>>> data = [[1, 2, 3], [1, 5, 6], [2, 5, 8], [2, 6, 9]]
|
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
|
... index=["tuna", "salmon", "catfish", "goldfish"])
|
>>> df
|
a b c
|
tuna 1 2 3
|
salmon 1 5 6
|
catfish 2 5 8
|
goldfish 2 6 9
|
>>> df.groupby("a").pct_change()
|
b c
|
tuna NaN NaN
|
salmon 1.5 1.000
|
catfish NaN NaN
|
goldfish 0.2 0.125
|
NzDThe 'fill_method' keyword being not None and the 'limit' keyword in z½.pct_change are deprecated and will be removed in a future version. Either fill in any non-leading NA values prior to calling pct_change or specify 'fill_method=None' to not fill NA values.rå c 3 ór K | ]/ \ }}|j « j j « 1 y wrk )r; r: r )rà rA rS s ro rÅ z%GroupBy.pct_change.<locals>.<genexpr>- s. è ø ò /Ù,2¨A¨s
|
×!Ñ!×%Ñ%×'ñ/ùs 57z#The default fill_method='ffill' in z¼.pct_change is deprecated and will be removed in a future version. Either fill in any non-leading NA values prior to calling pct_change or specify 'fill_method=None' to not fill NA values.rÔ Ú
|
pct_changer c ó0 | j ¬« S )N)rF Ú fill_methodrÆ rA r )rW )r r rY rA rÆ rF s ro r· z$GroupBy.pct_change.<locals>.<lambda>F s$ ø !,,Ø Ø 'ØØØð 'ó rq Tr rÕ )r )rF rA rä )r r r© rª r« rx r¬ r, r r r r ry rz r r rn r Úcodesr r# r? )
|
rm rF rY rÆ rA r rw ÚfilledÚfill_grprI s
|
````` ro rW zGroupBy.pct_changeè sê ü ðt s~~¨tÐ 4Ñ 4¸ÄSÇ^Á^Ñ8SÜ MMØVÜ:×&Ñ&Ð'ð (ðô
|
Ü+Ó-õ ð #..Ñ (ØÑ&¬3ñ /Ø6:ô/ô ,ô Ø9ÜDz×*Ñ*Ð+ð ,HðHô
|
"Ü /Ó 1õð "KØ CNNÑ "ØEà s~~Ñ %Ø88×,Ñ,¨TÓ2DØ × Ñ |Õ 4àDð Ð t qy÷Að ×-Ñ-¨a°×1CÑ1CÐRVÐ-ÓWÐ Wà Ð Ø!KØEØ+{Ó+°%Ô8Ø 99>Ø ~~ d§m¡m×&9Ñ&9ÀdÇoÁo~ÓVHà xx×'Ñ'¨¯ © ×(;Ñ(;ÈÏÉÐ'ÓXHØ..¨°t.Ó<Ø 99>Ø iiGØÑ AÑ%Ð%rq c óZ | j t d|« « }| j |« S )a
|
Return first n rows of each group.
|
|
Similar to ``.apply(lambda x: x.head(n))``, but it returns a subset of rows
|
from the original DataFrame with original index and order preserved
|
(``as_index`` flag is ignored).
|
|
Parameters
|
----------
|
n : int
|
If positive: number of entries to include from start of each group.
|
If negative: number of entries to exclude from end of each group.
|
|
Returns
|
-------
|
Series or DataFrame
|
Subset of original Series or DataFrame as determined by n.
|
%(see_also)s
|
Examples
|
--------
|
|
>>> df = pd.DataFrame([[1, 2], [1, 4], [5, 6]],
|
... columns=['A', 'B'])
|
>>> df.groupby('A').head(1)
|
A B
|
0 1 2
|
2 5 6
|
>>> df.groupby('A').head(-1)
|
A B
|
0 1 2
|
N©rÝ rç rÞ ©rm rÄ r? s ro Úheadz GroupBy.head\ s, ðF ×6Ñ6´u¸TÀ1³~ÓFØ×&Ñ& tÓ,Ð,rq c ó |r | j t | d« « }n| j g « }| j |« S )a°
|
Return last n rows of each group.
|
|
Similar to ``.apply(lambda x: x.tail(n))``, but it returns a subset of rows
|
from the original DataFrame with original index and order preserved
|
(``as_index`` flag is ignored).
|
|
Parameters
|
----------
|
n : int
|
If positive: number of entries to include from end of each group.
|
If negative: number of entries to exclude from start of each group.
|
|
Returns
|
-------
|
Series or DataFrame
|
Subset of original Series or DataFrame as determined by n.
|
%(see_also)s
|
Examples
|
--------
|
|
>>> df = pd.DataFrame([['a', 1], ['a', 2], ['b', 1], ['b', 2]],
|
... columns=['A', 'B'])
|
>>> df.groupby('A').tail(1)
|
A B
|
1 a 2
|
3 b 2
|
>>> df.groupby('A').tail(-1)
|
A B
|
1 a 2
|
3 b 2
|
Nr^ r_ s ro Útailz GroupBy.tail sA ñH Ø×:Ñ:¼5À!ÀÀT»?ÓKDà×:Ñ:¸2Ó>Dà×&Ñ& tÓ,Ð,rq c óº | j j d }||dk7 z }| j dk( r| j | S | j j dd
|f S )a
|
Return _selected_obj with mask applied to the correct axis.
|
|
Parameters
|
----------
|
mask : np.ndarray[bool]
|
Boolean mask to apply.
|
|
Returns
|
-------
|
Series or DataFrame
|
Filtered _selected_obj.
|
r r( N)r r/ r rz rè )rm r? rk s ro rÞ zGroupBy._mask_selected_obj s] ð mm×&Ñ& qÑ)ØsbyÑ!à 99>Ø×%Ñ% dÑ+Ð +à×%Ñ%×*Ñ*ª1¨d¨7Ñ3Ð 3rq c ó | j j }t |« dk( r|S | j r|S t d |D « « s|S |D cg c] }|j
|
}}| j j }||j |« |dgz }t j ||¬« } | j r| j « } | j r| j j | j « | ddd|i}
|
t! « rP|dk( rJt# |t$ « r1t# |j& t( « rd |
|
d< |j* di |
|
¤S t# |t, « rùt d
|
|j. D « « rÝ|j. } t1 j2 |j. d k( « d } | D ]8 } |j5 | |j6 dd
| f j9 t: « « : |j* di |
|
¤}| D ]V } |j6 dd
| f }|j5 | |j= |d k( d « j9 | j6 | « « X |S |j* di |
|
¤S t? |« D cg c] \ }}|j@ s||jB f" }}}t |« d kD r'tE | \ }}|jG tI |« d¬ « }|jK | j jL « j+ | d|¬« }t |« d kD r|jO ¬« }|jO d¬« S c c}w c c}}w )aI
|
If we have categorical groupers, then we might want to make sure that
|
we have a fully re-indexed output to the levels. This means expanding
|
the output space to accommodate all values in the cartesian product of
|
our groups, regardless of whether they were observed in the data or
|
not. This will expand the output space if there are missing groups.
|
|
The method returns early without modifying the input if the number of
|
groupings is less than 2, self.observed == True or none of the groupers
|
are categorical.
|
|
Parameters
|
----------
|
output : Series or DataFrame
|
Object resulting from grouping and applying an operation.
|
fill_value : scalar, default np.nan
|
Value to use for unobserved categories if self.observed is False.
|
qs : np.ndarray[float64] or None, default None
|
quantile values, only relevant for quantile.
|
|
Returns
|
-------
|
Series or DataFrame
|
Object (potentially) re-indexed to include all possible groups.
|
rä c 3 ó\ K | ]$ }t |j t t f« & y wrk )r» rB rD rV r s ro rÅ z*GroupBy._reindex_output.<locals>.<genexpr>ï s+ è ø ò
|
àô t×+Ñ+¬kÔ;KÐ-L× Mñ
|
ùs *,NrE r* Fr rI Ú c 3 ó< K | ] }t |t « y wrk )r» rI )rà r³ s ro rÅ z*GroupBy._reindex_output.<locals>.<genexpr> s è ø ò ;Ø7<Ju¤k×2ñ;ùs Ústringr )r> r )r* r )r T)Údropr )(r r r r r Ú _group_indexrÐ rE rX rO r rP r r Ú_get_axis_namer r r» r\ r³ rI r8 rN rP r½ rõ Úisetitemrè r¸ r¤ r? rL rQ r rÇ ri rñ Ú set_indexr, rV )rm ræ r rZ r« r r rb rÐ r5 ÚdÚ orig_dtypesr± r_ ÚcolrÊ Ú in_axis_grpsÚg_numsÚg_namess ro r] zGroupBy._reindex_outputÄ s ðB MM×+Ñ+ Ü y>QÒ ØMð ]]ØMô ñ
|
à!ô
|
ô
|
ð Mà5>Ö?¨Tt×(Ó(Ð? Ð?Ø ×#Ñ#Ø >ð × Ñ rÔ "ØTFNEÜ×'Ñ'¨ ¸5ÔAØ 99Ø×%Ñ%Ó'Eà ==ð ×'Ñ'¨¯ © Ó2°EØØ jðAô
|
"Õ#¨°%«Ü f¤fÔ-´*¸V¿\¹\Ì;Ô2WØ&(AlOØ)6>>Ñ.¨AÑ.Ð.Ü ¬ Ô2´sñ ;Ø@FÇ Á ô;ô 8ð #)§-¡-KÜ jj¨¯ © ¸(Ñ)BÓ CÀAÑ FGØ &ò QØ ¨¨V¯[©[º¸C¸Ñ-@×-GÑ-GÌÓ-OÕPðQà +V^^Ñ 0¨aÑ 0FØ &ò Ø $kkª!¨S¨&Ñ 1Ø Ø §¡¨#°©(°BÓ!7×!>Ñ!>¸{×?OÑ?OÐPSÑ?TÓ!Uõðð
|
"MØ!6>>Ñ& AÑ&Ð &ô -6°iÓ,@÷
|
Ù ( 4ÀDÇLÃLQ Nð
|
ñ
|
ô |Ó qÒ Ü ! <Ð 0OFGØ[[¬¨W« ¸A[Ó>Fð ×!Ñ! $§-¡-×"<Ñ"<Ó=×EÑEØ ¨*ð Fó
|
ô |Ó qÒ Ø×'Ñ'¨fÐ'Ó5Fà×!Ñ! tÐ!Ó,Ð,ùòE @ùób
|
s Á L=É7MÊ Mc ó¶ | j j r | j S t j |||« }|,t j | j || j
|
¬« }t j |« }| j j | j | j
|
« }g } |D ]k \ }
|
} | j |
|
} t | « } ||}n|J t || z « }t j | |||dn| |¬« }| j | | « m t j | « } | j j! | | j
|
¬« S )ab
|
Return a random sample of items from each group.
|
|
You can use `random_state` for reproducibility.
|
|
Parameters
|
----------
|
n : int, optional
|
Number of items to return for each group. Cannot be used with
|
`frac` and must be no larger than the smallest group unless
|
`replace` is True. Default is one if `frac` is None.
|
frac : float, optional
|
Fraction of items to return. Cannot be used with `n`.
|
replace : bool, default False
|
Allow or disallow sampling of the same row more than once.
|
weights : list-like, optional
|
Default None results in equal probability weighting.
|
If passed a list-like then values must have the same length as
|
the underlying DataFrame or Series object and will be used as
|
sampling probabilities after normalization within each group.
|
Values must be non-negative with at least one positive element
|
within each group.
|
random_state : int, array-like, BitGenerator, np.random.RandomState, np.random.Generator, optional
|
If int, array-like, or BitGenerator, seed for random number generator.
|
If np.random.RandomState or np.random.Generator, use as given.
|
|
.. versionchanged:: 1.4.0
|
|
np.random.Generator objects now accepted
|
|
Returns
|
-------
|
Series or DataFrame
|
A new object of same type as caller containing items randomly
|
sampled within each group from the caller object.
|
|
See Also
|
--------
|
DataFrame.sample: Generate random samples from a DataFrame object.
|
numpy.random.choice: Generate a random sample from a given 1-D numpy
|
array.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame(
|
... {"a": ["red"] * 2 + ["blue"] * 2 + ["black"] * 2, "b": range(6)}
|
... )
|
>>> df
|
a b
|
0 red 0
|
1 red 1
|
2 blue 2
|
3 blue 3
|
4 black 4
|
5 black 5
|
|
Select one row at random for each distinct value in column a. The
|
`random_state` argument can be used to guarantee reproducibility:
|
|
>>> df.groupby("a").sample(n=1, random_state=1)
|
a b
|
4 black 4
|
2 blue 2
|
1 red 1
|
|
Set `frac` to sample fixed proportions rather than counts:
|
|
>>> df.groupby("a")["b"].sample(frac=0.5, random_state=2)
|
5 5
|
2 2
|
0 0
|
Name: b, dtype: int64
|
|
Control sample probabilities within groups by setting weights:
|
|
>>> df.groupby("a").sample(
|
... n=1,
|
... weights=[1, 1, 1, 0, 0, 1],
|
... random_state=1,
|
... )
|
a b
|
5 black 5
|
2 blue 2
|
0 red 0
|
Nræ )rM ÚreplaceÚweightsÚ random_state)rz rì r? Úprocess_sampling_sizeÚpreprocess_weightsr rà rw r rð r± r ÚroundrE r½ rë r7 )rm rÄ Úfracru rv rw rM Ú weights_arrÚgroup_iteratorÚsampled_indicesr> r Ú grp_indicesÚ
|
group_sizeÚ sample_sizeÚ
|
grp_samples ro r? zGroupBy.sample9 sP ð| × Ñ × #Ò #à×%Ñ%Ð %Ü×+Ñ+¨A¨t°WÓ=Ø Ð Ü ×3Ñ3Ø×"Ñ" G°$·)±)ôKô ×'Ñ'¨ Ó5 à ×3Ñ3°D×4FÑ4FÈÏ É ÓRà Ø)ò <KFCØ ,, vÑ.KÜ [Ó)JØÐ Ø " àÐ'Ð'Ð'Ü # D¨:Ñ$5Ó 6 ä ØØ Ø Ø ' °[ÀÑ5MØ )ô Jð × "Ñ " ;¨zÑ#:Õ ;ð! <ô$ ..¨ Ó9Ø×!Ñ!×&Ñ& ¸T¿Y¹YÐ&ÓGÐGrq c óx t j ur< | j | j j « | j « n | j | j sYt d | j j D « « r2t j | j j D cg c] }t |j « c}« }t | j j « dk( r;t | j j d j j « « }n t | j j « }||k sJ ||k } | xr | }
|
| j" } |
|
r:t% | t& « r*r| j) « } t | j* « dkD }
|
|
|
ryt- d d« sh| j" j/ « j d¬« r>t1 j2 dt5 | « j6 d d
|
t8 t; « ¬ « dk( r0 fd } | _ | j= | | j" d ¬« } | S | jA d¬« } | S c c}w # t, $ r0}dk( rdnd}d| dt? |« v rt- d d« d d}~ww xY w)aª Compute idxmax/idxmin.
|
|
Parameters
|
----------
|
how : {'idxmin', 'idxmax'}
|
Whether to compute idxmin or idxmax.
|
axis : {{0 or 'index', 1 or 'columns'}}, default None
|
The axis to use. 0 or 'index' for row-wise, 1 or 'columns' for column-wise.
|
If axis is not provided, grouper's axis is used.
|
numeric_only : bool, default False
|
Include only float, int, boolean columns.
|
skipna : bool, default True
|
Exclude NA/null values. If an entire row/column is NA, the result
|
will be NA.
|
ignore_unobserved : bool, default False
|
When True and an unobserved group is encountered, do not raise. This used
|
for transform where unobserved groups do not play an impact on the result.
|
|
Returns
|
-------
|
Series or DataFrame
|
idxmax or idxmin for the groupby operation.
|
Nc 3 ó4 K | ] }|j y wrk r r s ro rÅ z)GroupBy._idxmax_idxmin.<locals>.<genexpr>á s è ø ò %
|
Ø)-D× $Õ $ñ%
|
ùr rä r z
|
Can't get zZ of an empty group due to unobserved categories. Specify observed=True in groupby instead.ræ zThe behavior of r zn with all-NA values, or any-NA and skipna=False, is deprecated. In a future version this will raise ValueErrorrå c ó2 t | « } |¬« S )N)r r r¨ )r )r r« r r¦ r¨ r s ro râ z$GroupBy._idxmax_idxmin.<locals>.func s ø Ü $ R¨Ó -FÙ! t°FÈ ÔVÐVrq Tr² rÌ ÚargmaxÚargminzattempt to get z of an empty sequence)r¨ r© r r )!r r r r r r r r r r r½ r r rj rB Úuniquer, rÚ r» rN r7 rN rÍ r; r© rª r« rx r¬ r, ry r r¯ )rm r¦ Úignore_unobservedr r r¨ r Ú expected_lenÚ
|
result_lenÚhas_unobservedÚ raise_errrb râ rò rÔ r s ` ``` ro rÞ zGroupBy._idxmax_idxminº s´ û ð> s~~Ñ %Ø|ØyyØ88×,Ñ,¨TÓ2DØ × Ñ sÕ +à99Dà}}¤ñ %
|
Ø15· ± ×1HÑ1Hô%
|
õ "
|
ô 77Ø48·M±M×4KÑ4KÖL¨DT×&Ñ&Õ'ÒLó Lô 4==×*Ñ*Ó+¨qÒ0Ü § ¡ ×!8Ñ!8¸Ñ!;×!KÑ!K×!RÑ!RÓ!TÓ U
|
ô ! § ¡ ×!;Ñ!;Ó <
|
Ø Ò-Ð -Ð-Ø '¨,Ñ 6Nà->Ð)>Ò)QÀ>Ið ×,Ñ,DÙZ¨¬iÔ 8Ù Ø ×1Ñ1Ó3DÜ § ¡ Ó -°Ñ 1 áÜ Ø ð &@ð @óð ñ Ø×(Ñ(×-Ñ-Ó/×3Ñ3¸Ð3Ô>Ü Ø&¤t¨D£z×':Ñ':Ð&;¸1¸S¸Eð B9ð 9ô "Ü /Ó 1õ ð 19ð ÷Wð !$ Ø ×3Ñ3Ø$×3Ñ3Àdð 4ó ð Mà×"Ñ"Ø%ØØØð #ó
|
ð ùò} Møô\ ò Ø#&¨(¢?x¸Ø$ T FÐ*?Ð@ÄCÈÃHÑLÜ$Ø$ S Eð *Pð Póð ð ð ûð ús Â: I;È5-J Ê J9Ê +J4Ê4J9c ó | j j | j « }|j dk( r |j |j
|
« }|S t |t « r|j « }|j }t |t j « sJ t |j
|
d¬« }t |t « rF|j |j j! |d|¬« |j" |j$ ¬« }|S i }t' |j( « D ]& \ }}|j j! |d|¬« ||< ( | j j ||j" ¬« }|j* |_ |S )Nr F)ÚcompatT)Ú
|
allow_fillr râ )r5 )r r. r rM r¸ r³ r» rX Ú to_flat_indexr4 r½ rÈ r< r\ r rê r7 r5 r rL r# rN ) rm r^ r5 rò r: r rb ÚkÚ column_valuess ro rÑ zGroupBy._wrap_idxmax_idxmin% sI Ø×"Ñ" 4§9¡9Ó-Ø 88q=ØZZ § ¡ Ó,Fð, ô) %¤Ô,Ø ×+Ñ+Ó-Ø[[FÜ f¤b§j¡jÔ1Ð 1Ð1Ü)¨%¯+©+¸eÔDHÜ#vÔ&à ×)Ñ)ØKK×$Ñ$ V¸ÈÐ$ÓRØ ))Ø ð *ó ð ð Ü(1°&·(±(Ó(;ò Ñ$A}Ø #kk× .Ñ .Ø%°$À8ð /ó DGðð ×.Ñ.¨t¸3¿9¹9Ð.ÓEØ!$§¡Ø rq )r r r r r r r r r úops.BaseGrouper | Noner zfrozenset[Hashable] | Noner
|
r r r r r r r r zbool | lib.NoDefaultr r r
r )r r )r rô r r r
r r )FF)r r r r )rò rû r
rû )rò úSeries | DataFramer
rN )rò r r
r rk )rò r rZ ú npt.NDArray[np.float64] | None)r: rñ r r r r )rb rN )râ r r| zdict[np.dtype, Any]r} údict[str, bool] | None)r r r
r )NFF) rw r rb rö r z bool | Noner r r¢ r r
r )Fr( )r¨ r r© rô r r r¤ úCallable | None)
|
r¦ r r: r r9 rô r§ r r
r )NFr( )r¦ r r§ r r¨ r r© rô )Fr )r¦ r r¨ r r r )T)rü r r
r )r
r )r r r
r )r
r )FNN)r¨ r r× ú!Literal['cython', 'numba'] | Noner} r )F)r¨ r r
r )rä NNF)r4 rô r× r r} r r¨ r )NFTFT) rW zSequence[Hashable] | NonerX r r r rü r r r r
rö )rä F)r4 rô r¨ r r
r rõ )Fr NN)r¨ r r© rô r× r r} r )r¨ r r© rô r
r )Fr( NN)Fr( T)r¨ r r© rô r r r
r )r
rN )NNN)r r r
ra )r
rd )r
rb )r
rc )rÐ zLiteral['ffill', 'bfill']rÆ ú
|
int | None)rÆ r )r
rU )rÄ zPositionalIndexer | tupler zLiteral['any', 'all', None]r
r )g à?rî F)r zfloat | AnyArrayLikerû r r¨ r )rü r ) r« r rü r r r r r r úAxisInt | lib.NoDefaultr
r )r úAxis | lib.NoDefaultr
r )r r r¨ r r
r )rF zint | Sequence[int]r r rG ú
|
str | None)rF rô r r r
r )rF rô rY z$FillnaOptions | None | lib.NoDefaultrÆ zint | None | lib.NoDefaultr r )é )rÄ rô r
r )r? znpt.NDArray[np.bool_]r
r )
|
ræ rû r r" rZ r r« r r
rû )NNFNN)
|
rÄ r r{ z float | Noneru r rv zSequence | Series | Nonerw zRandomState | None) r¦ zLiteral['idxmax', 'idxmin']r r r zAxis | None | lib.NoDefaultr r r¨ r r
r )r^ r r
r )[rx r r r rø r r r rp r r r# rB r! rU rW r_ rc rt r r r r( Ú _apply_docsr ry ry r¯ r¾ r rÖ rà rß rñ r rù r r) Ú_common_see_alsor rÅ rþ r& r. rÆ r= ri rÇ rM r+ Ú#_groupby_agg_method_engine_templater
|
rI Ú _groupby_agg_method_templater r r r r r rN r± r¹ r½ r¿ rÁ rÒ rÔ rÄ rÚ rä ræ r r r r# rö r/ r; r? rô rW r` rb rÞ r½ rø r] r? rÞ rÑ r rq ro r r Ë s¨
ñAðF Ó ØNà
|
ð %)ØØ#'Ø*.Ø15Ø'+Ø ØØ Ø),¯ © Øð:Oà ð:Oð "ð:Oð ð :Oð
|
!ð :Oð (ð :Oð /ð:Oð %ð:Oð ð:Oð ð:Oð ð:Oð 'ð:Oð ð:Oð
|
ò :Oó ð:Oóx
|
ð òó ðð$ ò1ó ð1ðl ð "'Ø "ð Að ðAð ò Aó ðAðF ðØ)ðà òó ðð2 ò ó ð ð> òó ðð ð .2ð'0à"ð'0ð +ò'0ó ð'0ðZ "'Ø "ð (ð ð(ð ð (ð
|
ó (ð ò
|
ó ð
|
ð4+àð+ð +ð+ð .ó +ðZ Ø?Có !Gó ð!GðF Ø?Có "ó ð"ñN ØJÑ ×&Ñ&Ø ¨ Ð4HÑ(Ið 'ó
|
óð
|
9=ô ?ó ð
|
?ðB ð
|
)-Ø "Ø ð +
|
à ð+
|
ð !ð+
|
ð &ð +
|
ð
|
ð +
|
ð ð +
|
ð
|
ò+
|
ó ð+
|
ðZ ð #Øð?ð #'ñ ?àð?ð ð?ð
|
ð ?ð ò ?ó ð?ð$-9Øð-9Ø )ð-9Ø14ð-9Ø;Cð-9à ó-9ð^ ð $Ø "Øð /à ð/ð ð/ð ð /ð
|
ò /ó ð/ðd EFð(Øð(Ø&*ð(Ø:Aó(ð
|
Ø-1Àó '<ó ð'<ðR òó ðð< ñó ðð ó#ó ð#ðN Ø ò%ó ó ð%ð ÙyÔ!ÙÐ+Ô,ó3
|
ó -ó "ó ð3
|
ðj ÙyÔ!ÙÐ+Ô,ó4
|
ó -ó "ó ð4
|
ðl ÙyÔ!ÙÐ+Ô,ò`:ó -ó "ó ð`:ðD ÙyÔ!ÙÐ+Ô,ð #Ø48Ø04ð YCàðYCð 2ðYCð .ò YCó -ó "ó ðYCðv óM?ó ðM?ð^ ÙyÔ!ÙÐ+Ô,ð Ø48Ø04Ø "ð hàðhð 2ðhð .ð hð
|
ò hó -ó "ó ðhðT ÙyÔ!ÙÐ+Ô,ð Ø48Ø04Ø "ð fàðfð 2ðfð .ð fð
|
ò fó -ó "ó ðfðP ð -1Ø ØØ Øð MDà)ðMDð ðMDð ð MDð
|
ð MDð ð MDð
|
òMDó ðMDð^ óS
|
ó ðS
|
ðj ÙyÔ!ÙÐ+Ô,ò\ó -ó "ó ð\ð| ÙØ+ØØ Ø Ø
|
Ø Ùð ó!
|
ô)ðX #ØØ48Ø04ð Làð Lð ð Lð 2ð Lð
|
.ò LóU)ó ðV Lð< ÙØ$ØØ Ø Ùð ó!
|
ô 'óP
|
óQ'ó ðR
|
ð
|
ÙØ+ØØ Ø Ø
|
Ø Ùð ó!
|
ô)ðX #ØØ48Ø04ð àðð ðð 2ð ð
|
.ò óU)ó ðVð2 ÙØ+ØØ Ø Ø
|
Ø Ùð ó!
|
ô)ðX #ØØ48Ø04ð àðð ðð 2ð ð
|
.ò óU)ó ðVð2 àNRðM
|
Ø ðM
|
Ø58ðM
|
ØGKðM
|
à òM
|
ó ðM
|
ð^ àNRðB
|
Ø ðB
|
Ø58ðB
|
ØGKðB
|
à òB
|
ó ðB
|
ðH òWó ðWñr × Ñ Ó ð ØØð #ð
|
|
ò #ó ð#ðJ Ø;?ô B
|
ó ðB
|
ðH òI
|
ó ðI
|
ðV ÙyÔ!Ù Ð Ó ò
|
ó ó "ó ð
|
ð$ ÙyÔ!Ù Ð Ó ò
|
ó ó "ó ð
|
ð" óQó ðQðf ÙyÔ!óY0ó "ó ðY0ðv ÙyÔ!óL0ó "ó ðL0ð\ Ø ÙyÔ!ÙÐ+Ô,òX(ó -ó "ó ó ðX(ðz /3ð8à $ð8ð ,ð8ð
|
ó 8ðt ð #&Ø %Ø "ð a=à ða=ð ða=ð ò a=ó ða=ðF ÙyÔ!óPó "ó ðPðd ÙyÔ!ó7:ó "ó ð7:ðr ÙyÔ!ÙÐ+Ô,ð Ø Ø ØØ(+¯©ð g
|
àðg
|
ð ðg
|
ð ð g
|
ð
|
ð g
|
ð &ð g
|
ð
|
òg
|
ó -ó "ó ðg
|
ðR ÙyÔ!ÙÐ+Ô,à+.¯>©>ð8;Ø(ð8;à ò8;ó -ó "ó ð8;ðt ÙyÔ!ÙÐ+Ô,à+.¯>©>ð8:Ø(ð8:à ò8:ó -ó "ó ð8:ðt ÙyÔ!ÙÐ+Ô,ð ),¯©Ø "ðF
|
à%ðF
|
ð ðF
|
ð
|
|
ò F
|
ó -ó "ó ðF
|
ðP ÙyÔ!ÙÐ+Ô,ð ),¯©Ø "ðF
|
à%ðF
|
ð ðF
|
ð
|
|
ò F
|
ó -ó "ó ðF
|
ðP ÙyÔ!ð ()Ø Ø%(§^¡^Ø>>Ø !ð Y
|
à$ðY
|
ð #ð Y
|
ð ò Y
|
ó "ó ðY
|
ðv ÙyÔ!ÙÐ+Ô,à ÀÇÁð_ Øð_ Ø&=ð_ à ò_ ó -ó "ó ð_ ðB ÙyÔ!ÙÐ+Ô,ð Ø<?¿N¹NØ,/¯N©NØ Ø%(§^¡^ð o&àðo&ð :ðo&ð *ð o&ð #ò o&ó -ó "ó ðo&ðb ÙyÔ!ÙÐ+Ô,ó!-ó -ó "ó ð!-ðF ÙyÔ!ÙÐ+Ô,ó&-ó -ó "ó ð&-ðP ò4ó ð4ð, ð VVØ-1Ø !ð r-à#ðr-ð ðr-ð +ð r-ð
|
ð r-ð
|
ò r-ó ðr-ðh ð Ø !Ø Ø,0Ø+/ð ~Hà ð~Hð ð~Hð ð ~Hð
|
*ð ~Hð )ò ~Hó ð~HðF #(Ø,/¯N©NØØ "ð ià (ðið ðið *ð ið
|
ð ið ð ið
|
óiôVrq r c ó t | t « r ddlm} |}n't | t « r ddlm} |}nt d| « || ||||¬« S )Nr )Ú SeriesGroupBy)ÚDataFrameGroupByzinvalid type: )r r r r r )r» r\ Úpandas.core.groupby.genericr¤ rN r¥ r )r Úbyr r r r¤ rÝ r¥ s ro Ú get_groupbyr¨ A sV ô #vÔ Ý=à Ü CÔ #Ý@à ä.¨¨Ð.Ó/Ð/á Ø Ø Ø ØØ ô ð rq c ó¢ t |« }t |« j « \ }}t ||« }| j rt t | « } t | j « |gz }| j D cg c] }t j ||« c}t j |t | « « gz }t ||| j dgz ¬« }|S t | « } t t j | « | « }
|
| |g}t j |
|
|« t j || « g}t ||| j dg¬« }|S c c}w )a
|
Insert the sequence 'qs' of quantiles as the inner-most level of a MultiIndex.
|
|
The quantile level in the MultiIndex is a repeated copy of 'qs'.
|
|
Parameters
|
----------
|
idx : Index
|
qs : np.ndarray[float64]
|
|
Returns
|
-------
|
MultiIndex
|
N)r' rZ rÐ )r rW Ú factorizer- Ú _is_multir rX rñ r' rZ r½ r÷ rî rÐ rû r ) r_ rZ r Ú lev_codesrT r' r rZ ÚmiÚnidxÚ idx_codess ro r\ r\ ^ s ô b'CÜ2Y×(Ñ(Ó*NIsÜ$ Y°Ó4Ià
|
}}Ü:sÓ#ÜcjjÓ! S EÑ)Ø,/¯I©IÖ6 q1cÕ"Ò6¼"¿'¹'À)ÌSÐQTËXÓ:VÐ9WÑWÜ v¨U¸#¿)¹)ÀtÀfÑ:LÔ Mð Iô 3xÜ(¬¯©°4« ¸#Ó> ØsÜ9 cÓ*¬B¯G©G°I¸tÓ,DÐEÜ v¨U¸3¿8¹8ÀTÐ:JÔ Kà Iùò 7s Á7 E a- {}.{} operated on the grouping columns. This behavior is deprecated, and in a future version of pandas the grouping columns will be excluded from the operation. Either pass `include_groups=False` to exclude the groupings or explicitly select the grouping columns after groupby to silence this warning.)Nr NT) r rO r§ r r r r r r r r
r )r_ rW rZ znpt.NDArray[np.float64]r
rX )§r Ú
|
__future__r Úcollections.abcr r r r r¼ Ú functoolsr r r Útextwrapr
|
Útypingr r r r r r r r© Únumpyr½ Úpandas._configr Úpandas._config.configr Ú pandas._libsr r Úpandas._libs.algosr Úpandas._libs.groupbyÚ_libsrn rÎ Úpandas._libs.missingr Úpandas._typingr r r r r r r r r r! r" r# r$ Úpandas.compat.numpyr% r( Ú pandas.errorsr& r' Úpandas.util._decoratorsr( r) r* r+ Úpandas.util._exceptionsr, Úpandas.core.dtypes.castr- r. Úpandas.core.dtypes.commonr/ r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r: Úpandas.core.dtypes.missingr; r< r= Ú pandas.corer> r? Úpandas.core._numbar@ Úpandas.core.applyrA Úpandas.core.arraysrB rC rD rE rF rG rH Úpandas.core.arrays.string_rI Ú pandas.core.arrays.string_arrowrJ rK Úpandas.core.baserL rM Úpandas.core.commonÚcoreÚcommonrà Úpandas.core.framerN Úpandas.core.genericrO Úpandas.core.groupbyrP rQ rR Úpandas.core.groupby.grouperrS Ú pandas.core.groupby.indexingrT rU Úpandas.core.indexes.apirV rW rX rY rZ Ú pandas.core.internals.blocksr[ Úpandas.core.seriesr\ Úpandas.core.sortingr] Úpandas.core.util.numba_r^ r_ r` r· ra r¼ rb rc rd r r r¢ r¡ rú Ú_transform_templateÚ_agg_template_seriesÚ_agg_template_frameri rñ Ú _KeysArgTyper rû r r¨ r\ r r rq ro ú<module>rÝ s ðñõ #÷ó ó ÷ó Ý ÷÷ ñ ó ã å -Ý 0÷õ 'ß )Ð )Ý #÷÷ ÷ õ õ /÷÷ó õ 5÷÷ ÷ ÷ ó ÷ ñ ÷ õ (Ý 4÷÷ ñ õ 3÷÷÷ !Ð Ý 'Ý '÷ñ õ
|
4÷÷õ õ <Ý %Ý 6÷ñ
|
Ýå.÷ñ ð Ð ðAðD@ðB2ñIw ðr Ð ð4&'Ð #ðP5ðn\Ð ð|PÐ ðdMÐ ð` ô,ó ó ðð2 Ø ØNØ hZÐ !Ñ"Ø8*hÐ&Ñ 'Ñ(Ø HhÐ Ñ ð !ñ ôF, ¨xÑ 8Ð:Nô FñT Ð 3¸7ÔCÐ ôsIk(Ñ#ô sIñlS W ð #ØØ&*Øð Ø ðàðð ðð $ð ð
|
ð ð ò ó ðó8 ðHñ rq
|
