Mh&SrSSKJr SSKJrJrJrJr SSKrSSK J r J r SSK r SSK Jr SSKJrJrJrJrJrJrJr SSKrSSKrSSKJr SS KJrJr SS KJ r SSK!J"s J#r$ SS K%J&r& SS K'J(r(J)r)J*r*J+r+J,r,J-r-J.r.J/r/J0r0J1r1J2r2J3r3J4r4 SS K5J6r7 SSK8J9r9J:r: SSK;Jr>J?r? SSK@JArA SSKBJCrCJDrD SSKEJFrFJGrGJHrHJIrIJJrJJKrKJLrLJMrMJNrNJOrOJPrP SSKQJRrRJSrSJTrT SSKUJVrVJWrW SSKXJYrY SSKZJ[r[ SSK\J]r]J^r^J_r_J`r`JaraJbrbJcrc SSKdJere SSKfJgrgJhrh SSKiJjrjJkrk SSKlJms Jnro SSKpJqrq SSKrJsrs SSKtJuruJvrvJwrw SSKxJyry SSKzJ{r{J|r| SS K}J~r~JrJrJrJr SS!KJr SS"KJr SS#KJr SS$KJrJr \(aSS%KJr SS&KJr SS'KJrJrJr S(rS)S*S+S,.rS-rS.rS/rS0rS1rS2r\"S3S4\j55r\\\\\\/\4\\\/\4\\\44r"S5S6\j\k\/\{5r\"S7\sS89r"S9S:\\/5r\?"\5S>S?S;jj5rS@S<jrS=rg)Aa 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)HashableIteratorMappingSequenceN)partialwraps)dedent) TYPE_CHECKINGCallableLiteralTypeVarUnioncastfinal)option_context) Timestamplib)rank_1d)NA) AnyArrayLike ArrayLikeAxisAxisIntDtypeObj FillnaOptions IndexLabelNDFrameTPositionalIndexer RandomStateScalarTnpt)function)AbstractMethodError DataError)Appender Substitutioncache_readonlydoc)find_stack_level)coerce_indexer_dtypeensure_dtype_can_hold_na) is_bool_dtypeis_float_dtype is_hashable is_integeris_integer_dtype is_list_likeis_numeric_dtypeis_object_dtype is_scalarneeds_i8_conversion pandas_dtype)isnana_value_for_dtypenotna) algorithmssample)executor)warn_alias_replacement)ArrowExtensionArrayBaseMaskedArray CategoricalExtensionArray FloatingArray IntegerArray SparseArray) StringDtype)ArrowStringArrayArrowStringArrayNumpySemantics) PandasObjectSelectionMixin) DataFrame)NDFrame)basenumba_ops) get_grouper)GroupByIndexingMixinGroupByNthSelector)CategoricalIndexIndex MultiIndex RangeIndex default_index)ensure_block_shape)Series)get_group_index_sorter)get_jit_argumentsmaybe_use_numba)Any) Resampler)ExpandingGroupbyExponentialMovingWindowGroupbyRollingGroupbyz 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 `) 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 `) when compared to the input. >>> g2.apply(lambda x: x.max() - x.min()) a 1 b 0 dtype: int64)templatedataframe_examplesseries_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 `_ 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}c2\rSrSrSrSSjrSrS SjrSrg) GroupByPlotiz= Class implementing the .plot attribute for groupby objects. cXlgN_groupby)selfgroupbys M/var/www/html/env/lib/python3.13/site-packages/pandas/core/groupby/groupby.py__init__GroupByPlot.__init__s c^^UU4SjnSUlURRX0RR5$)Nc(>UR"T0TD6$ri)plot)rlargskwargss rnfGroupByPlot.__call__..fs99d-f- -rqrt)__name__rk_python_apply_general _selected_obj)rlrurvrws `` rn__call__GroupByPlot.__call__s0 . }}221mm6Q6QRRrqc^^UU4SjnU$)Ncx>^^UUU4SjnTRRUTRR5$)Nc<>[URT5"T0TD6$ri)getattrrt)rlrurvnames rnrw0GroupByPlot.__getattr__..attr..fstyy$/@@@rq)rkrzr{)rurvrwrrls`` rnattr%GroupByPlot.__getattr__..attrs, A==66q$--:U:UV Vrq)rlrrs`` rn __getattr__GroupByPlot.__getattr__s W  rqrjN)rmGroupByreturnNonerstr) ry __module__ __qualname____firstlineno____doc__ror|r__static_attributes__rrqrnrgrgs Srqrgc\rSrSr%\R 1Sk-rS\S'S\S'SrS\S 'SrS \S 'S \S '\ SSj5r \ S Sj5r \ \ S!Sj55r \ \ S"Sj55r\ \ SSj55r\ \ S#Sj55r\ S5r\ S5r\ \S55r\ S$Sj5r\"S\"S5S9\"\5S%Sj55r\ S&S'Sjj5r\ S(Sj5rSrg)) BaseGroupByi> objaxiskeyssortleveldropnagrouperas_indexobserved exclusions group_keysrrops.BaseGrouper_grouperN_KeysArgType | NonerIndexLabel | Nonerboolrc,[UR5$ri)lengroupsrls rn__len__BaseGroupBy.__len__s4;;rqc,[RU5$ri)object__repr__rs rnrBaseGroupBy.__repr__st$$rqc[R"[U5RS3[[ 5S9 UR $)NzI.grouper is deprecated and will be removed in a future version of pandas.)category stacklevel)warningswarntypery FutureWarningr+rrs rnrBaseGroupBy.groupers?  Dz""#$( ("')  }}rqc.URR$)a1 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} )rrrs rnrBaseGroupBy.groups%s\}}###rqc.URR$ri)rngroupsrs rnrBaseGroupBy.ngroupsUs}}$$$rqc.URR$)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(, {Timestamp('2023-01-01 00:00:00'): [0, 1], Timestamp('2023-02-01 00:00:00'): [2, 3]}) )rindicesrs rnrBaseGroupBy.indicesZs`}}$$$rqc^ ^ Sn[U5S:Xa/$[UR5S:a[[UR55nOSnUSn[ U[ 5(a[ U[ 5(d Sn[ U5e[U5[U5:Xd UVs/sHo`RUPM sn$UVs/sH o"U5PM snm U 4SjU5nOU"U5m U 4SjU5nUVs/sHo`RRU/5PM sn$s snf![anSn[ U5UeSnAff=fs snfs snf)zL Safe get multiple indices, translate keys for datelike to underlying repr. c[U[R5(aS$[U[R5(aS$S$)Nc[U5$ri)rkeys rnABaseGroupBy._get_indices..get_converter..s9S>rqc,[U5R$ri)rasm8rs rnrrs9S>#6#6rqcU$rirrs rnrrs3rq) isinstancedatetimenp datetime64)ss rn get_converter/BaseGroupBy._get_indices..get_converters:!X..//11Ar}}--66&&rqrNz# UH!n[S[TU555v M# g7f)c36# UHupU"U5v M g7frir).0rwns rn 5BaseGroupBy._get_indices...sB,ADA1Q44,AsN)tuplezip)rr converterss rnr+BaseGroupBy._get_indices..s&UutUBC D,ABBBus),c34># UH nT"U5v M g7frir)rr converters rnrrs7Yt__s) rrnextiterrr ValueErrorKeyErrorget) rlnamesr index_sample name_samplemsgrerrrrrs @@rn _get_indicesBaseGroupBy._get_indicess@ ' u:?I t|| q T\\ 23LLAh lE * *k511T o%{#s<'88 3;@A54LL.5AA5AALq-*LAJUuUE&l3I77E7<=ut   r*u==!B36%S/s2 3B>s6&D/*D*D/ E%E*D// E 9EE c,URU/5S$)zA Safe get index, translate keys for datelike to underlying repr. r)r)rlrs rn _get_indexBaseGroupBy._get_indexs   $(++rqc[UR[5(a UR$URb?[ UR5(aURUR$UR $UR$ri)rrrZ _selectionr0_obj_with_exclusionsrs rnr{BaseGroupBy._selected_objsc dhh ' '88O ?? &4??++xx00 ,, ,xxrqc6URR5$ri)r_dir_additionsrs rnrBaseGroupBy._dir_additionssxx&&((rqra >>> 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)klassexamplesc6[R"X/UQ70UD6$ri)compipe)rlfuncrurvs rnrBaseGroupBy.pipes:xx4T4V44rqcURnURn[U5(a[U5S:Xd[U5(ap[U5S:Xaa[ U[ 5(a[U5S:XaUSnO7[ U[ 5(d"[ R"S[[5S9 URU5n[U5(d [U5eUc8URS:XaUO [S5U4nURRU$[ R"S[[5S9 UR!XPRS9$)ay 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 rzWhen 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.rNzobj 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)rrr3rrrrrrr+rrrslicer{iloc_take_with_is_copy)rlrrrrindsindexers rn get_groupBaseGroupBy.get_groupsLyy    CJ!O   3t9>$&&3t9>Awe,, $"/1 t$4yy4. ;"ii1nd5;2EG%%**73 3 MM=+-  ))$YY)? ?rqcnURnURnURRURUR S9n[ U5(a1[U5S:Xa"[R"S[[5S9 [U[5(a[U5S:Xa SU5nU$)aZ 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 rrzCreating 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.rc30# UH upU4U4v M g7frir)rrgroups rnr'BaseGroupBy.__iter__..s?*#vuos)rrr get_iteratorr{rr3rrrrr+rlist)rlrrresults rn__iter__BaseGroupBy.__iter__isPyy ++D,>,>TYY+O   3u:? MM4+-   dD ! !c$i1n??F rqr)rint)rr)rr)rzdict[Hashable, np.ndarray])rz$dict[Hashable, npt.NDArray[np.intp]])rzset[str])rz/Callable[..., T] | tuple[Callable[..., T], str]rr"rirDataFrame | Series)rz#Iterator[tuple[Hashable, NDFrameT]])ryrrrrJ _hidden_attrs__annotations__rrrrrpropertyrrrrrrr)r{rr(r r'_pipe_templaterrr rrrqrnrrs .. 2 M M $D $#E #     % %     ,$ ,$\  % %  .% .%` 0> 0>d , ,   & ) )  ,n5=5 5-.5 h@ h@T X XrqrOutputFrameOrSeries)boundc  \rSrSr%SrS\S'S\S'\SSSSSSS S S \RS 4 SkS jj5r SlS jr \SmS j5r \SnS j5r \SoSpSjj5r \SqSj5r\SrSj5r\SsSj5r\StSuSjj5rSoSvSjjr\SwSj5rSxSjr\SS.Sj5r\SS.Sj5r\"\SR3S\SS95S S.SySjj5r\SzS{S jj5r\S|SS".S}S#jjj5rS~S$jr\SSS%jj5rSSS&jjr\SSS'.S(j5r \SsS)j5r!\S*5r"\SSS+jj5r#\\$SS,j55r%\\&"S-S.9\&"\'S/9SSS0jj555r(\\&"S-S.9\&"\'S/9SSS1jj555r)\\&"S-S.9\&"\'S/9SS2j555r*\\&"S-S.9\&"\'S/9SSS3jj555r+\SSS4jj5r,\\&"S-S.9\&"\'S/9SSS6jj555r-\\&"S-S.9\&"\'S/9SSS7jj555r.\SSS8jj5r/\SSS9jj5r0\\&"S-S.9\&"\'S/9SS:j555r1\\2"\3S;SSSS\4"S<5S=9SSS>jj55r5\\2"\6S?SS\4"S@5SA9SSSBjj55r7\\2"\3SCSS!SS\4"SD5S=9SSSEjj55r8\\2"\3SFSS!SS\4"SG5S=9SSSHjj55r9\SSSIjj5r:\SSSJjj5r;\SSKj5r<\2"\=R|5SSSLjj5r>\S S.SSMjj5r?\SSNj5r@\\&"S-S.9\"\'5SSOj555rA\\&"S-S.9\"\'5SSPj555rB\StSSQjj5rC\\&"S-S.9StSSRjj55rD\\&"S-S.9StSSSjj55rE\\$\&"S-S.9\&"\'S/9SSTj5555rFStSSUjjrG\SSSVjj5rH\\&"S-S.9SSSWjj55rI\\&"S-S.9SSSXjj55rJ\\&"S-S.9\&"\'S/9SYS SZS\R4SS[jj555rK\\&"S-S.9\&"\'S/9\R4SS\jj555rL\\&"S-S.9\&"\'S/9\R4SS]jj555rM\\&"S-S.9\&"\'S/9\RS4SS^jj555rN\\&"S-S.9\&"\'S/9\RS4SS_jj555rO\\&"S-S.9S5S\R\RS4SS`jj55rP\\&"S-S.9\&"\'S/9S5\R4SSajj555rQ\\&"S-S.9\&"\'S/9S5\R\RS\R4SSbjj555rR\\&"S-S.9\&"\'S/9SSScjj555rS\\&"S-S.9\&"\'S/9SSSdjj555rT\SSej5rU\\VRS4SSfjj5rX\SSSgjj5rYS\RS S4SShjjrZSSijr[Sjr\g)ria 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 rrrrNrTc Xpl[U[5(d[U55eX@lU(dUS:wa [ S5eXlX lXlXl Xl Uc1[UUUUU U [RLaSOU URS9upVnU [RLaE[SUR55(a"[ R""S[$['5S9 Sn XlXlUR-U5UlXPlU(a[3U5Ulg[35Ulg)Nrz$as_index=False only valid for axis=0F)rrrrrc38# UHoRv M g7fri_passed_categoricalrpings rnr#GroupBy.__init__..<sJ8I++8IzThe 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)rrrMrrrrrrrrrQr no_defaultany groupingsrrrr+rr_get_axis_numberrr frozensetr) rlrrrrrr selectionrrrrrs rnroGroupBy.__init__s $#w''2c2' qy !GHH   $ ?'2"*cnn"<({{( $G s~~ %J8I8IJJJ 8"/1 H ((.  3=)J/9;rqcXR;a[RX5$XR;aX$[ S[ U5R SUS35e)N'z' object has no attribute ')_internal_names_setr__getattribute__rAttributeErrorrry)rlrs rnrGroupBy.__getattr__Ms\ ++ +**46 6 88 : T ##$$?vQ G  rqcUS:Xa<[R"[U5RSUS3[[ 5S9 g[R"S[U5RSUS3[[ 5S9 g)Nr.zo with axis=1 is deprecated and will be removed in a future version. Operate on the un-grouped DataFrame insteadrzThe 'axis' keyword in z\ is deprecated and will be removed in a future version. Call without passing 'axis' instead.)rrrryrr+)rlrrs rn_deprecate_axisGroupBy._deprecate_axisWs| 19 MM:&&'q/$$+-   MM(d)<)<(=QtfE77+-  rqc:^^^ [[UR5U5m [R"T 5nST;aFTS[ R La0URRTS5nURXQ5 OST;aUS:XaOUS:XaSTS'OSTS'SUR;aDTRSS5b"TRS5[ R LaURTS'UU U4SjnXl U[R;aUR!X`R"5$U[R$;nUR!UURUU(+S9nUR&R((aU(aUR+U5nU$)zT"U/TQ70TD6$rir)xrurwrvs rncurried&GroupBy._op_via_apply..curriedsQ((( (rq) is_transformnot_indexed_same)rrrinspect signaturerrrr"r. parametersrrryrNplotting_methodsrzr{transformation_kernelsrhas_dropped_na_set_result_index_ordered) rlrrurvsigrr5r7r rws `` @rn _op_via_applyGroupBy._op_via_applyjsm D223T :" V vcnn D88,,VF^set_axisrU result_ilocs sort_indexrWrWr)rlr obj_axisoriginal_positionss rnr?!GroupBy._set_result_index_ordereds88%%dii0 == % %dmm.J.J__XIIE_JFM#4==#=#=#?@!3))%P"" "2 == ' '^^Js8}$=DII^NF F rqc [U[5(aUR5nURn[ [ UR R5[ UR R55[ UR RVs/sHo3RPM sn55HLupEnXB;dM U(aURSXE5 M(Sn[R"U[[5S9 MN U$s snf)NrzA 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.messagerr)rrZto_framecolumnsrreversedrrget_group_levelsr!in_axisinsertrrrr+)rlr rogrprlevrrrs rn_insert_inaxis_grouperGroupBy._insert_inaxis_groupers ff % %__&F.."% T]](( ) T]]335 6 T]]-D-DE-Dckk-DE F# Dw"MM!T/Y MM #!.#3#5## . )FsDcURS:XaiURnURRURR5(a)URRR 5UlU$)Nr)rr"rTrQrrI)rlr s rn_maybe_transpose_resultGroupBy._maybe_transpose_resultsR 99>XXF||""488>>22 $xx~~224  rqcLUR(dJURU5nUR5n[[ UR R 55nOUR RnUb [X25nX1l URU5nURXBS9$)z Wraps the output of GroupBy aggregations into the expected result. Parameters ---------- result : Series, DataFrame Returns ------- Series or DataFrame qs) rrv _consolidaterUrLrrrK_insert_quantile_levelrTry_reindex_output)rlr r}rTress rn_wrap_aggregated_outputGroupBy._wrap_aggregated_output*s(}}008F((*F% 5 567EMM..E >+55E **62##C#//rqc[U5erir%)rldatarYr8r7s rn_wrap_applied_outputGroupBy._wrap_applied_outputTs"$''rqcZURRup#nURRnURRnUR XPR S9R 5nURn[U[5(ab[URR5S:a [S5eURRSRn URU 5nUR U5R 5n [R "Xd5upU U U U4$)Nrrz_Grouping with more than 1 grouping labels and a MultiIndex is not supported with engine='numba'r)rrN _sort_idx _sorted_idsrVrto_numpyrTrrVrr!NotImplementedErrorrget_level_valuesrgenerate_slices) rlridsr`r sorted_index sorted_ids sorted_data index_data group_keysorted_index_datastartsendss rn _numba_prepGroupBy._numba_prep`s--22}}.. ]].. ii 99i=FFH ZZ j* - -4==**+a/)H //277I#44Y?J&OOL9BBD**:?        rqc UR(d [S5eURS:Xa [S5eURnURS:XaUOUR 5n[ R"UUS40[U5D6nURRun n URRn URR"U4XS.UD6n URRU RS'UR!XRS9n URS:Xa$U R#S5n UR$U lU $UR&U lU $) zX Perform groupby with a standard numerical aggregation function (e.g. mean) with Numba. zgenerate_shared_aggregatorr\rrNr_mgrapplyrKrP_constructor_from_mgrsqueezerro) rlr dtype_mapping engine_kwargsaggregator_kwargsrdf aggregatorrr`rres_mgrr s rn_numba_agg_generalGroupBy._numba_agg_general{s6}}%N  99>%&@A A((YY!^T88     .  MM,, Q--''''--  " 7H --44 Q))' )E 99>^^I.F))FK "\\FN rq)rc 6URnURS:XaUOUR5nURU5upxp[R "U5 [R "U40[X$5D6n U "U U UU[UR5/UQ76n U R[R"U 5SS9n URn URS:XaSUR0nU R5n OSUR0nUR "U 4SU 0UD6$)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. rrrrrrorT)rrXrnrrO validate_udfgenerate_numba_transform_funcr\rrorVrargsortrTrravel _constructor)rlrrrurvrrrrrrnumba_transform_funcr rT result_kwargss rn_transform_with_numbaGroupBy._transform_with_numbas ((YY!^T262B2B22F/lD!%CC  %m< &      O    RZZ 5A>  99>#TYY/M\\^F& 5M  FuF FFrqc |URnURS:XaUOUR5nURU5upxp[R "U5 [R "U40[X$5D6n U "U U UU[UR5/UQ76n URRn URS:XaSUR0nU R5n OSUR0nUR"U 4SU 0UD6nUR(d*UR!U5n[#[U55UlU$)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. rrrrorT)rrXrnrrOrgenerate_numba_agg_funcr\rrorrKrrrrrvrXrT)rlrrrurvrrrrrrnumba_agg_funcr rTrrs rn_aggregate_with_numbaGroupBy._aggregate_with_numbas((YY!^T262B2B22F/lD!77  %m<       O     ** 99>#TYY/M\\^F& 5MEeE}E}}--c2C%c#h/CI rqrc dataframerd)inputr)include_groupscp^^^Tn[R"T5mUT:wa[RUn[XU5 [ T[ 5(ab[ UT5(aB[UT5n[U5(aU"T0TD6$T(dT(a[ST35eU$[STS35eT(dT(a2[T5(a[T5UUU4Sj5nO [S5eTnU(dURXR5$[SS5 URXR5n [ UR ["5(dUR$cwURR&URR&:waI[(R*"[,R/[1U5R2S5[4[75S9 SSS5 U $![a' URXR5ssSSS5 $f=f!,(df  W $=f) Nz"Cannot pass arguments to property z$apply func should be callable, not 'r'c>T"U/TQ70TD6$rir)grurrvs rnrwGroupBy.apply..fs3D3F33rqz6func must be a callable if args or kwargs are suppliedzmode.chained_assignmentrrl)ris_builtin_func_builtin_table_aliasr?rrhasattrrcallabler TypeErrorr rzrrr{rrZrshaperr_apply_groupings_deprformatrryDeprecationWarningr+) rlrrrurv orig_funcaliasrrwr s ` `` rnr GroupBy.applys  ""4(  ,,Y7E "4E : dC tT""dD)C==///V$'I$%PQQ  "FtfA NOO V~~t44!LA--a1J1JK K5t < P33A7I7IJ"488V44/**00D4M4M4S4SSMM 5 < < J//!"4#3#5 =4  P11!5N5NOO1= < P= <4 s+(H&*B>G22%H#H&"H##H&& H5cURRXUR5upgUcUnURUUUU5$)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 )rapply_groupwiserr)rlrwrr8r7is_aggrYmutateds rnrzGroupBy._python_apply_general:sLF--77K  #& ((       rqrG)npfuncc dUR"SUUUUS.UD6nURURSS9$)N)howalt numeric_only min_countrmmethodr_cython_agg_general __finalize__r)rlrrrrrvr s rn _agg_generalGroupBy._agg_generalhsK)) %    ""488I">>rqcUceURS:Xa [USS9nOF[URURS9nUR SS:XdeUR SS2S4nURRXTSS9nUR[:XaUR[SS9n[XsS 9$![a*nS US URS 3n [U5"U 5UeSnAff=f) zV Fallback to pure-python aggregation if _cython_operation raises NotImplementedError. NrFrIdtyperT)preserve_dtypezagg function failed [how->z,dtype->])rX)rXrZrLr"rrrr agg_series ExceptionrrastyperY) rlrrYrXrserr res_valuesrrs rn_agg_py_fallbackGroupBy._agg_py_fallback{s ;;! e,C6886<<8B88A;!# ##''!Q$-C  *11#41PJ 99 #**6*>J "*88 *.se8CII;aHCs)C.c ) *s(B33 C'=%C""C'c ^^^^^^ TRUTS9m SUU UUUU4SjjnT RU5nTRU5nTS;aTRU5nTR U5n TR S:XaU R SS9n U $)Nrrc>TRR"SUT4TRS- TS.TD6nU$![a* TS;a[ U[ 5(aOTbTS;aeOf=fTceTR TUTRTS9nU$)N aggregaterrrr all)r rstdsem)rXr)r_cython_operationrXrrrFr)rYr rrrrvrrls rn array_func/GroupBy._cython_agg_general..array_funcs 88Q'   & '  .(Z -L-L[C+G$G%H ? "?**3TYYC*PFMs/4%A( A('A(idxminidxmaxrFrrYrrr)_get_data_to_aggregategrouped_reduce_wrap_agged_manager_wrap_idxmax_idxminrr infer_objects) rlrrrrrvrnew_mgrroutrs ``` `` @rnrGroupBy._cython_agg_generals** 3*O  6%%j1&&w/ & &**3/C**3/ 99>###/C rqc [U5erir)rlrrrrvs rn_cython_transformGroupBy._cython_transforms"$''rq)enginercUn[R"U5=(d UnXa:wa [XU5 [U[5(dUR "XU/UQ70UD6$U[ R;aSUS3n[U5eU[ R;dU[ R;aUbX%S'X5S'[X5"U0UD6$[R"USS5 US;a+[[SU5nUR"US/UQ70UD6nOUbX%S'X5S'[X5"U0UD6nSSS5 UR!W5$!,(df  N=f)Nr'z2' is not a valid function name for transform(name)rrrTr)rget_cython_funcr?rr_transform_generalrNtransform_kernel_allowlistrcythonized_kernelsr=r temp_setattrrr _idxmax_idxmin_wrap_transform_fast_result) rlrrrrurvrrr s rn _transformGroupBy._transforms^ ""4(0D   "4D 9$$$**4XXQWX X 88 8dVMNCS/ ! T,, ,8S8S0S!#)x *7'4&77 7!!$ D9//(: ;TBD!00tMdMfMF)+1x(2?/$T0$A&AF:33F; ;:9s AE EcdURnURRun nURURRUR SS9nUR RS:XaG[R"URU5nURXRRURS9nU$URS:XaSO UR nURURU5nUR!XxU40SSS9nUR#UR%UR 5US9nU$) z' Fast transform path for aggregations. FrHrrTrrT) allow_dupsrIr)rrrNrWrKrrrXr<take_ndrSrrTrrPrV_reindex_with_indexersrerM) rlr rrr`routputrnew_axs rnr#GroupBy._wrap_transform_fast_results ''MM,, Q : :QVW 88==A $$V^^S9C%%c%JF  q(1diiD[[&++C0F22}%$U3F__S]]499%=D_IF rqcx[U5S:Xa[R"/SS9nO*[R"[R"U55nU(a%UR R XRS9nU$[R"[UR R5[S9nURS5 SXAR[5'[R"U[UR R SS5S/-5R"nUR R%U5nU$)Nrint64rrFTr)rrarrayr concatenater{rVremptyrTrfillrr tiler rr"where)rlrrfilteredr^s rn _apply_filterGroupBy._apply_filter%s w<1 hhr1GggbnnW56G ))..wYY.GH 88C 2 2 8 89FD IIe (,D$ %774d&8&8&>&>qr&B!Cqc!IJLLD))//5Hrqc URRup#n[X$5nX%[U5pbUS:Xa#[R "S[R S9$[RSUSSUSS:g4n[R"[R[R"U5SU45nU)R5n U(aU [R"XU5-n O3[R"U [RUSSS4U5U - n URR(aF[R"US:H[RU R[R SS95n OU R[R SS9n [R "U[R"S9n [R$"U[R"S9X'X$) z 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 rrTNrGrFr)rrNr[rrrrr_diffnonzerocumsumrepeatr>r nanrfloat64intparange) rl ascendingrr`rsortercountrunreprrevs rn_cumcount_arrayGroupBy._cumcount_array6sj--22'5[#c(U A:88ARXX. .eeD#cr(c!"g--.ggbeeBJJsOA.567tmmo  299SXs+ +C))Cc!"gtm 45s;cAC == ' '((3"9bffcjj%j.PQC**RXXE*2ChhuBGG,iiRWW5 xrqc[UR[5(aURR$[UR[5(deURR $ri)rrrL_constructor_slicedrZrrs rn_obj_1d_constructorGroupBy._obj_1d_constructor^sL dhh * *88// /$((F++++xx$$$rqrmr)see_alsoc.^URSU4SjTS9$)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 c2>[USS9RTS9$NFr)skipna)rZr r4r?s rnrGroupBy.any..&/3363Brqrr?rrlr?s `rnr  GroupBy.anygs'd'' B(  rqc.^URSU4SjTS9$)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 rc2>[USS9RTS9$r>)rZrr@s rnrGroupBy.all..rBrqrCrDrEs `rnr GroupBy.alls'f'' B(  rqc^^^ ^ UR5nURRumnm TS:gm URS:HmS UUU U 4SjjnUR U5nUR U5n[ R"USS5 URU5nSSS5 URWSS9$!,(df  N=f) a 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 rGrcn>URS:Xa T[U5RSS5)-nOT[U5)-n[R"UTTS9n[ U[ 5(a;[US[R"URS[RS9S9$[ U[5(aF[ UR[5(d'[S5n[!U5R#USUS9$T(a,URS:XdeURSS:XdeUS$U$) NrrG)r]max_binrr)r^zint64[pyarrow]r)rXr9reshapercount_level_2drrArErzerosrbool_r@rrGr8r_from_sequence)bvaluesmaskedcountedrr is_seriesr^rs rnhfuncGroupBy.count..hfunc s||q g!6!6q"!= ==g.((WMG'?33#AJRXXgmmA.>bhh%OG%899* {CC%%56G}33GAJe3LL||q(((}}Q'1,,,qz!NrqrTNr fill_value)rSrrr) rrrNrXrrrr rr) rlrr`rWrnew_objr rrVr^rs @@@@rnr0 GroupBy.countsv**,--22QbyIIN   0%%e,**73   dJ 511':F6##Fq#996 5s B22 Cc^[U5(a&SSKJn URU[R USS9$UR SU4SjTS9nURURSS9$) a 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_periodsmeanc2>[USS9RTS9$NFr)r)rZrar4rs rnrGroupBy.mean.. sfQU388l8Srqrrrmr) r]pandas.core._numba.kernelsr^rr>float_dtype_mappingrrr)rlrrrr^r s ` rnra GroupBy.mean= szZ 6 " " ?**,, + --S).F &&txx &B Brqcb^URSU4SjTS9nURURSS9$)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 medianc2>[USS9RTS9$rc)rZrkrds rnr GroupBy.median.. s&/66L6Qrqrfrmrr)rlrr s ` rnrkGroupBy.median s@R)) Q%*  ""488I">>rqrc ^[U5(a;SSKJn [R"UR U[ RUSTS95$URSU4SjUTS9$)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_varr`ddofrc2>[USS9RTS9$NFr)rs)rZrr4rss rnrGroupBy.std..S fQU377T7Brqrrrs) r]rgrqrsqrtrr>rhrrlrsrrrrqs ` rnr GroupBy.std ssr 6 " " >77''00! ! ( ++B) , rqc^[U5(a'SSKJn URU[R USTS9$UR SU4SjUTS9$)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 rrprrvarc2>[USS9RTS9$ru)rZr~rvs rnrGroupBy.var.. rxrqry)r]rgrqrr>rhrr{s ` rnr~ GroupBy.varX sgr 6 " " >**,, + ++B) , rqc $ URS:Xa [S5eU(aSOSnURnURnURR V s1sH!oR (dMU RiM# n n [U[5(aURn X;a/OU/n O[UR5n UbJ[U5nU[U 5-nU(a[SUS35eX- nU(a[SUS35eOU n[UR5VV s/sH'unn X;dM X;dMURSS2U4PM) n nn [URR 5nU HAn[!UUURUR"S US 9un nU[UR 5- nMC UR%UUR"UR&UR(S 9n[+[UR-55nUUl[/S U55(a\UVs/sHnUR0PM nn[2R4"UUVs/sHnURPM snS 9nUR7USS9nU(aUR9USS9nUR"(aUR:R<n[?[AU55UR:l[[?[AURR 555nURCUS S9nUUR:lU(a[[?[AURR 5UR:RD55nUR%UR:RGU5UR"UR(S S9RIS5nUU-nURKS5nURL(aUnOUR:n [NRP"U R<5n!UU!;a[SUS35eUUlU RS[?[AU!555UlURU5n"URR SRRRVn#[YU!U#S9R[[AU!5U5n$U$U"l U"nUR]URSS9$s sn fs sn nfs snfs snf)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. rz1DataFrameGroupBy.value_counts only handles axis=0 proportionr0NzKeys z0 in subset cannot be in the groupby column keys.z) in subset do not exist in the DataFrame.F)rrrrr)rrrc3# UH=n[UR[[45=(a UR(+v M? g7fri)rgrouping_vectorrBrT _observed)rgroupings rnr(GroupBy._value_counts.. sB & x//+?O1P Q '&&& '%sAArrrYstable)r.kind)rsort_remaining)rrrsumgzColumn label 'z' is duplicate of result columnr value_countsr)/rrrrrr!rrrrrZsetror enumeraterr rQrrmrrrsizer  _result_indexrV from_productrW sort_valuesrTrrLrrgnlevels droplevel transformr2rrfill_missing_names set_names reset_indexrrUrsr)%rlsubset normalizerr.rrrrr in_axis_names_namer unique_cols subsettedclashing doesnt_existidxr!rrr`gb result_seriesr levels_list multi_indexr index_levelrFindexed_group_sizer rTro result_frame orig_dtypecolss% rn _value_countsGroupBy._value_counts s 99>%C  )|g XX''+/--*A*A *AhEUEUMHMM*A   c6 " "HHE/2cUDckk*K!K $s='99$z*33 )6 $ ~.23 ( #,CKK"8#9JC-!272D!C "8 001 C'YYYY MGQ g//0 0IZZ ]];;   VRWWY/ !   &   ;DD)$4--)KD$11)#D)$DII)#DK*11+!1LM )55#(6M 99!''--E(-c%j(9M   %uS)@)@%ABCK)44!%5M).M   % c$--112M4G4G4O4OPF"/!6!6##--f5YY{{ "7" i  / /M*005M =="F"''E,,U[[9Gw >$7V!WXX!%M "'//%G 2E"FM (446L00377??EEJ 3::3w<ND#'L !F""488N"CCm 2HE#Ds*S=/S=) T9TT0TT c.^U(axURRS:Xa^[URR5(d:[ [ U5R SUSURR35eURSU4SjUTS9$)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 rz.sem called with numeric_only=z and dtype rc2>[USS9RTS9$ru)rZrrvs rnrGroupBy.sem.. s&/333>rqry)rrXr4rrrryr)rlrsrs ` rnr GroupBy.semS sT DHHMMQ.7G7W7W:&&'( ,~[8HJ '' >% (  rqcURR5nSn[UR[5(a[URR [ 5(a[[URR [5(aSnOZ[URR [5(aSnO.SnO+[URR [5(aSn[UR[5(a$URXRRS9nOURU5nUbURSSSSUS9n[R"USS5 URUS S 9nSSS5 UR (dUR#S 5R%5nU$!,(df  N@=f) 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 Nnumpy_nullablepyarrowr:F)rconvert_stringconvert_booleanconvert_floating dtype_backendrTrrYr)rrrrrZrr@rIrHrAr8rconvert_dtypesrr rrrenamer)rlr rs rnr GroupBy.size s`t##%EI dhh ' '$((..*=>>dhhnn.LMM$(M0@AA$4M$-MDHHNNO<< 0  dhh ' '--f88==-IF--f5F  $**#$ %!&+ +F  dJ 5))&Q)?F6}}]]6*668F 6 5s -F88 Gra 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)fnamenomceekexamplec2[U5(a&SSKJn URU[R UUS9$[ R"USS5 URUUS[RS9nSSS5 URWSS9$!,(df  N=f) Nr) grouped_sumr_rTrrrrrrY) r]rgrrr>default_dtype_mappingrr rrrr)rlrrrrrr s rnr GroupBy.sum sd 6 " " >**..% + !!$ D9**!-'66 +:''1'= =:9s !B Bproda 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)rrrrc@URXS[RS9$)Nrr)rrr)rlrrs rnr GroupBy.prodS s+T  %&QSQXQX!  rqmina  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[U5(a'SSKJn URU[R UUSS9$UR UUS[RS9$)Nrgrouped_min_maxFr`is_maxrr) r]rgrrr>identity_dtype_mappingrrrrlrrrrrs rnr GroupBy.min sjd 6 " " B**//% + $$)#vv % rqmaxa  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[U5(a'SSKJn URU[R UUSS9$UR UUS[RS9$)NrrTrrr) r]rgrrr>rrrrrs rnr GroupBy.max sjd 6 " " B**//% + $$)#vv % rqc6SSSjjnURUUSUUS9$)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 cSSjn[U[5(aURX!S9$[U[5(aU"U5$[ [ U55e)NcUR[UR5n[U5(d URRR$US$)z-Helper function for first item that isn't NA.rrr;rrna_valuer4arrs rnfirst2GroupBy.first..first_compat..firstC s>ggeAGGn-3xx77==1111v rqrr4rZrrLrrZrr)rrrs rn first_compat#GroupBy.first..first_compatB sM #y))yyy22C((Sz!S **rqrrrrrr?rrrrrr)rlrrr?rs rnr GroupBy.first s1r +  % !  rqc6SSSjjnURUUSUUS9$)aC 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 cSSjn[U[5(aURX!S9$[U[5(aU"U5$[ [ U55e)NcUR[UR5n[U5(d URRR$US$)z,Helper function for last item that isn't NA.rGrrs rnlast/GroupBy.last..last_compat..last s>ggeAGGn-3xx77==1112wrqrrr)rrrs rn last_compat!GroupBy.last..last_compat sM #y))yyy11C((Cy S **rqrrrrr)rlrrr?rs rnr GroupBy.lastY s1\ +  % !  rqcURRS:XaURn[UR5nU(d [ S5eUR RSURSSSS9n/SQnURRX0R RUS 9nURU5$URS 5nU$) 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 rzNo numeric types to aggregaterohlcrrGr)openhighlowclose)rTroc"UR5$ri)r)sgbs rnrGroupBy.ohlc.. s CHHJrq) rrXr{r4rr&rrrS_constructor_expanddimrKr_apply_to_column_groupbys)rlr is_numericr agg_namesr s rnr GroupBy.ohlc sL 88==A $$C)#))4J ?@@88S[[&qB9J9IXX44--"<"URTTTS9$)Nr)describe)r4rrrs rnr"GroupBy.describe.. s!** +Wg%rqr8)rrrrXunstackrnr"rrr rzrrrvrXrT)rlrrrr describedr s ``` rnrGroupBy.describe s'' s8q= ''%Ixx1}""**,??$&&++BQ/ /   dJ 5//!% 0F6 99>88O!}}008F(V5FL #6 5s D D)c*SSKJn U"X/UQ7SU0UD6$)aS Provide resampling when using a TimeGrouper. Given a grouper, the function resamples it according to a string "string" -> "frequency". See the :ref:`frequency 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 )rlrulerrurvr s rnresampleGroupBy.resamples3z D*   .< @F  rqchSSKJn U"UR/UQ7URURS.UD6$)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 `__. 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 `__. 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)rb)r _as_index)pandas.core.windowrbr{rr)rlrurvrbs rnrollingGroupBy.rollingsED 6     ]]mm     rqcRSSKJn U"UR/UQ7SUR0UD6$)z Return an expanding grouper, providing expanding functionality per group. Returns ------- pandas.api.typing.ExpandingGroupby r)r`r)rr`r{r)rlrurvr`s rn expandingGroupBy.expanding/s= 8     ]]    rqcRSSKJn U"UR/UQ7SUR0UD6$)z Return an ewm grouper, providing ewm functionality per group. Returns ------- pandas.api.typing.ExponentialMovingWindowGroupby r)rar)rrar{r)rlrurvras rnewm GroupBy.ewmDs> F-     ]]    rqc*^^ UcSnTRRun n[R"USS9R [R SS9nUS:XaUSSS2n[ [RUUUTRS9m S U U4S jjnTR5nURU5nTRU5n TRS :Xa'U Rn TRR U lTRR"U lU $) 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. NrG mergesort)rFrbfill)r] sorted_labelslimitrc>[U5nURS:XaI[R"UR[R S9nT"X!S9 [ R"X5$[U[R5(a\URnTRR(a[UR5n[R"URUS9nO-[U5RURURS9n[!U5HZupV[R"URS[R S9nT"X!US9 [ R"Xb5XESS24'M\ U$)Nrr)rr^)r9rXrrrr,r<rrndarrayrrr>r-r_emptyr) rYr^rrri value_elementcol_funcrls rnblk_funcGroupBy._fill..blk_funcsiiG"hh..GO rqc"URSUS9$)a 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 ffillr r-rlr s rnr0 GroupBy.ffillsvzz'z//rqc"URSUS9$)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 rr1r2r3s rnr GroupBy.bfill s\zz'z//rqc[U5$)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: [] )rSrs rnnth GroupBy.nthYsx"$''rqcU(dEURU5nURRun nX4S:g-nURU5nU$[ U5(d [ S5eUS;a[ SUS35e[ [U5nURRX RS9n[U5[UR5:Xa URnOURRn URRU RUR5nURR(a+US:Hn [ R""U [$U5n ['U SS9nURS :Xa/UR(R+XR,UR.S 9n O$UR+XR,UR.S 9n U R1U5$) NrGz4dropna option only supported for an integer argumentrz_For a DataFrame or Series groupby.nth, dropna must be either None, 'any' or 'all', (was passed z).)rrInt64rr)rr)"_make_mask_from_positional_indexerrrN_mask_selected_objr1rrr r{rrr codes_infoisinrTr>rr rrUr"rmrrr8) rlrrr^rr`rdroppedrrnullsrYgrbs rn_nth GroupBy._nths ::1=D 00ICA"9%D))$/CJ!}}ST T  '%hb*  aL$$++YY+G w<3t112 2mmG ==%%Dmm..tyy/GHG}}++2 %W5g6 99>))##Gmm$))#TC//'MM /RCwwqzrqc ^^^^^^^TRUSS9nTRU5nTRS:XaETRR UR TRS9nUR R nO0TRR UTRS9nUR n[R"URUR5upS U4SjjmS U4Sjjm[R"U[RS9n U n [U5(a&[R"U/[RS9n Sn TRRupm[!U 5m[#[$R&U U TUU S 9mSUUUUU4S jjnUR(R+U5nTRU5nTR-UU S 9$)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 quantilerrrc>[UR5(a [S5eSn[U[5(aK[ UR5(a1UR [[RS9nURnX!4$[UR5(aa[U[5(a#UR [[RS9nOUn[R"[R5nX!4$[UR5(a:[U[5(a%UR [[RS9nX!4$[UR5(aR[R"S[!T5R"S3[$['5S9 [R("U5nX!4$[+UR5(aURnX4$[U[5(ac[-UR5(aI[R"[R.5nUR [[RS9nX!4$[R("U5nX!4$)Nz7'quantile' cannot be performed against 'object' dtypes!)rrzAllowing 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)r5rrrrAr4rfloatrr*r2rCrr.rrrryrr+asarrayr7r/r+)vals inferencerrls rn pre_processor'GroupBy.quantile..pre_processor,stzz**M*.I$005Edjj5Q5Qmm%"&&mA JJ F> !E"$**--dN33--ebff-ECCHHRXX. :> !9tzz**z$/O/Omm%"&&mA6> !5tzz** -d4j.A.A-BC00"/1 jj& > !%TZZ00 JJ &D.11nTZZ6P6PHHRZZ0 mm%"&&mA> !jj&> !rqc>U(Ga;[U[5(aUceTS;a[U5(d [X5$[R "5 [R "S[S9 [U5"URUR5U5sSSS5 $[U5(aTS;d[U5(aEURS5RURR5nUR!U5$[U["R5(deURU5$U$!,(df  U$=f)N>linearmidpointignore)ri8)rrAr/rDrcatch_warningsfilterwarningsRuntimeWarningrr numpy_dtyper2r7view_ndarrayr_from_backing_datar)rJrK result_mask orig_vals interpolations rnpost_processor(GroupBy.quantile..post_processorZs4 i99&222$(>>~!HH -T?? &446$33H~V#' ? $ $-$9$9!"!, $76%Y//%)??*955 ${{4055%..44  );;  &i::::;;y11K;76:Ks AE ErN)r]r}r\rrc >Un[U[5(a2URn[R"T T 4[R S9nO [ U5nSn[UR5nT"U5upVSnURS:XaURSn[R"UT T 4[RS9nU(aURS5nURS:XaT "USUUUUS9 O"[U5Hn T "XXYX)SUS9 M URS:Xa&URS5nUbURS5nOUR!UT T -5nT "XX15$)NrrrrrR)rYr^rZis_datetimelikeK)rrA_maskrrPrQr9r7rrXrrr+rWrLrrN)rYr[r^rZr`rJrKncolsrr$rrnqsr]rLs rnr'"GroupBy.quantile..blk_funcsKI&/22|| hh~RXXF F|" 1&,,?O+F3ODEyyA~ 1 ((E7C0 CCyyyyA~F +$3 uA#w!W$((7 &yyA~iin*"-"3"3C"8Kkk%37!#+I Irqr|)rJrrz"tuple[np.ndarray, DtypeObj | None]) rJ np.ndarrayrKzDtypeObj | NonerZznp.ndarray | Noner[rrrr)rrrr _get_splitterr" _sorted_datarr_slabelsrrrr+r6rNrrr)group_quantilerrr)rlqr\rr,rsplittersdatarrr}pass_qsrr`r'rrrrrdr]rLs` ` @@@@@rnrFGroupBy.quantiles`))|*)U&&s+ 99>}}22355tyy2IH))++E}}223TYY2GH))E**8+<+N>NO , "\0 0 &0 +0 ! 0   0 dXXarzz *%' Q<<1#RZZ0BG--22"g  % %'  0 J0 Jd**++H5&&w/++CG+<>> 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 rrGc38# UHoRv M g7frirrs rnr!GroupBy.ngroup.. sL4KD''4Krdense) ties_methodrr)rrMrrrNr>rr r*r+rr r!rr8r)rlr.rrTcomp_idsrr s rnngroupGroupBy.ngroups@'' dii(==++A. == ' 'xxBAHJJEHHE LDMM4K4KL L LxW=AH))()G\\A%.F rqcURRUR5nURUS9nUR X25$)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.)rrMrr4r8)rlr.rT cumcountss rncumcountGroupBy.cumcount)sCn))33DII>((9(= '' 99rqaveragekeepcf^^ US;a Sn[U5eT[RLa.URR T5mUR TS5 OSmUUUUS.m TS:wa7T R S5T S'UU 4SjnURXpRS S 9nU$UR"S S TS .T D6$)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)rtr. na_optionpctrtrc.>UR"STSS.TD6$)NF)rrrrr4rrvs rnrGroupBy.rank..s!&&IdI&IrqTr7F)rrr) rrrrr"r.poprzr{r) rlrr.rrrrrwr rvs ` @rnr GroupBy.rankdsX 5 5GCS/ ! s~~ %88,,T2D  v .D"""   19%zz-8F8 IA//%%D0FM%%      rqc4^^[R"SUTSS/5 T[RLa.URR T5mUR TS5 OSmTS:wa!UU4SjnURX@RSS9$UR"S0TD6$) 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 cumprodrr?rc,>UR"SST0TD6$Nrrrrs rnr!GroupBy.cumprod..s!))888rqTrr nvvalidate_groupby_funcrrrr"r.rzr{rrlrrurvrws ` ` rnrGroupBy.cumprods`   D&>8:TU s~~ %88,,T2D  y 1D 198A--a1C1CRV-W W%%:6::rqc4^^[R"SUTSS/5 T[RLa.URR T5mUR TS5 OSmTS:wa!UU4SjnURX@RSS9$UR"S0TD6$) 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(rr?rc,>UR"SST0TD6$rr(rs rnr GroupBy.cumsum..Es!((777rqTrrrrs ` ` rnr(GroupBy.cumsum s`   4.(9ST s~~ %88,,T2D  x 0D 197A--a1C1CRV-W W%%9&99rqc L^URSS5nT[RLa.URR T5mUR TS5 OSmTS:wa9U4SjnUR nU(aUR5nURXVSS9$URSX$S9$)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?TcumminrcD>[RRUT5$ri)rminimum accumulater4rs rnr GroupBy.cummin.."**//48rqrrr? rrrrr"r.r{_get_numeric_datarzrrlrrrvr?rwrs ` rnrGroupBy.cumminJrHd+ s~~ %88,,T2D  x 0D 198A$$C++---a4-H H%% <&  rqc L^URSS5nT[RLa.URR T5mUR TS5 OSmTS:wa9U4SjnUR nU(aUR5nURXVSS9$URSX$S9$)a 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?TcummaxrcD>[RRUT5$ri)rmaximumrrs rnr GroupBy.cummax..rrqrrrrs ` rnrGroupBy.cummaxrrqc p^^^^T[RLa.URRT5mUR TS5 OSm[ U5(aDTS:Xa [ S5e[[U5n[U5S:Xa [ S5eSSK J n SnOP[U5(d[SUS [U5S 35eU(a [ S 5e[[U5/nS n/nUGHm[T5(d[STS [T5S 35e[[T5mTcTS:wa$UUUU4Sjn UR!XR"SS9n OT[RLaS mUR$R&upn [(R*"[U 5[(R,S9n[.R0"XU T5 UR2nUR5UR6UR8UR6U40TSS9n U(aU[;U [<5(a[[>U RA55n U RCU(aUST3OST35n URE[[F[<[H4U 55 GM [U5S:XaUS$W"USS9$)ai 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 shiftrrz:If `periods` contains multiple shifts, `axis` cannot be 1.z0If `periods` is an iterable, it cannot be empty.rDTzPeriods must be integer, but z is r-z/Cannot specify `suffix` if `periods` is an int.FNc,>URTTTT5$ri)r)r4rrZfreqperiods rnrGroupBy.shift..YsaggD$ rqrr)rZrr`r)%rrrr"r.r3rrrrrJrEr1rrr rzr{rrNrrPrr)group_shift_indexerrrrrPrrZrrn add_suffixappendrrL)rlperiodsrrrZsuffixrErshifted_dataframesrwshiftedrr`r res_indexerrrs ``` @rnr GroupBy.shiftsl s~~ %88,,T2D  w /D  qy P8W-G7|q  !STT 9Jg&&3G9DgqQ !RSSC)*GJFf%%3F84V ~QO#v&F41944))5/!%J"&--":": hhs3xrxx@ ..{&Q//44YY$))!4k BC)#5 gv.."8W-=-=-?@G!,,,2vhax(!F8   % %d51B+CW&M NGN%&!+ q ! *3 rqcX^^T[RLa.URRT5mUR TS5 OSmTS:waUR UU4Sj5$UR nURTS9nSS/nURS:Xa%URU;aURS5nX4- $URR5VVs/sHupgXu;dM UPM nnn[U5(a"URUVs0sHofS_M sn5nX4- $s snnfs snf) aW 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&rc$>URTTS9$)N)rr)r&)r4rrs rnrGroupBy.diff..swT(Jrq)rint8int16rfloat32)rrrr"r.rrrrXrrdtypesitemsr) rlrrrr dtypes_to_f32cr to_coerces `` rnr& GroupBy.diff}s V s~~ %88,,T2D  v .D 19::JK K''**W*- ) 88q=yyM)!..3 } ,/::+;+;+=X+=xqAW+=IX9~~!.. )J 1Y, )JK} Y)Js D!"D! D'cL^^^^^T[RS4;dT[RLa9[R"S[ U5R S3[ [5S9 T[RLaeT[RLaP[SU55(a9[R"S[ U5R S3[ [5S9 SmT[RLaSmT[RLa.URRT5mURTS 5 OS mTcTS :wa$UUUUU4S jnURX`RS S 9$TcSmS m[UT5"TS9nURS :Xa/UR!UR"R$UR&S9nO8UR(R!UR"R$UR&S9nUR+TTS9n URS:Xa U R(n Xy- S- $)am 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.rc3v# UH/upUR5RR5v M1 g7fri)r9rYr )rr`rts rnr%GroupBy.pct_change..&s-/6:FA !!%%''ds79z#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.r0 pct_changerc*>URTTTTTS9$)N)r fill_methodr rr)r)r4rrrr rs rnr$GroupBy.pct_change..?s"!,,' 'rqTrr1)r)rrr)rrrrrryrr+r rr"r.rzr{rrrmrcodesrr"r) rlrrr rrrwfilledfill_grprs ````` rnrGroupBy.pct_changest s~~t4 4S^^8S MMV:&&'( +-  #.. (&3/6:/,, 9Dz**+,HH "/1"K CNN "E s~~ %88,,T2D  | 4D  tqyA--a1C1CRV-W W  !KE{+%8 99>~~dmm&9&9doo~VHxx'' (;(;'XH..t.< 99>iiG A%%rqcZUR[SU55nURU5$)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 Nr<rr=rlrr^s rnhead GroupBy.headUs,F66uT1~F&&t,,rqcU(aUR[U*S55nOUR/5nURU5$)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 Nrrs rntail GroupBy.tail{sAH ::5!T?KD::2>D&&t,,rqcURRSnXS:g-nURS:XaURU$URRSS2U4$)z 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. rrGN)rrNrr{r)rlr^rs rnr=GroupBy._mask_selected_objs[mm&&q)by! 99>%%d+ +%%**1d73 3rqcURRn[U5S:XaU$UR(aU$[ SU55(dU$UVs/sHoUR PM nnURR nUbURU5 US/-n[R"XgS9nUR(aUR5nUR(a=URRUR5USSSU0n UR "S0U D6$[#U5V Vs/sH%upUR$(dMXR&4PM' n n n[U 5S:a#[)U 6upUR+[-U 5SS 9nUR/URR05R!USUS 9n[U 5S:aUR3W S 9nUR3S S 9$s snfs snn f)a 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. rc3b# UH%n[UR[[45v M' g7fri)rrrBrTrs rnr*GroupBy._reindex_output..s- ! t++k;K-L M M!s-/NrrIFrZr)r]r)rIrZ)rT)dropr)rr!rrr  _group_indexrrrVrrrrr_get_axis_namerrWrrrrrrr  set_indexrKr)rlrrZr}r!rrrrTdr$ in_axis_grpsg_numsg_namess rnrGroupBy._reindex_outputs@MM++ y>Q M]]M !   M5>?YT((Y ? ## >   r "TFNE'' A 99%%'E =='' 2EjA >>&A& &-6i,@ ,@yDLLNQ N,@   | q !<0OF[[W A[>F!!$--"<"<=EE *F  | q ''f'5F!!t!,,a@> sG20G7 G7c URR(a UR$[R"XU5nUb)[R"URX@R S9n[ R"U5nURRURUR 5n/n UHjupURU n [U 5n UbUnOUce[X--5n[R"U UUUcSOWU US9nU RX5 Ml [R"U 5n URR!XR S9$)a* 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)rreplaceweights random_state)r{rr=process_sampling_sizepreprocess_weightsrrrrrrrroundrrrrV)rlrfracrrrr weights_arrgroup_iteratorsampled_indicesr]r grp_indices group_size sample_size grp_samples rnr=GroupBy.samples?|    # #%% %++AW=   33""G))K'' 5 33D4F4F R)KF,,v.K[)J" '''#D$56   '[5M) J  " ";#: ;!*$..9!!&&YY&GGrqc^^^^T[RLa=Tc URmURR T5mUR TT5 O URmUR (Gd[SURR55(GaT[R"URRVs/sHn[UR5PM sn5n[URR5S:Xa;[URRSRR55nO[URR 5nX::deX:n U(+=(a U n UR"n U (aD[%U [&5(a/T(aU R)5n [U R*5S:n U (a[-STS35eOoT(dhUR"R/5RSS9(a<[0R2"S[5U5R6S TS 3[8[;5S 9 TS:Xa-UUUU4S jn TU lUR=XR"S S9n U $URATSTTS9n U $s snf![,a3nTS:XaSOSnSUS3[?U5;a[-STS35SeeSnAff=f)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. Nc38# UHoRv M g7frirrs rnr)GroupBy._idxmax_idxmin..s% 1H $ $1Hrrrz Can't get zZ of an empty group due to unobserved categories. Specify observed=True in groupby instead.rzThe behavior of r-zn with all-NA values, or any-NA and skipna=False, is deprecated. In a future version this will raise ValueErrorrc,>[UT5nU"TTTS9$)N)rr?r)r)rrrrrr?s rnr$GroupBy._idxmax_idxmin..funcs$R-F!tFVVrqTrrargmaxargminzattempt to get z of an empty sequence)rrrr?)!rrrrr"r.rr rr!rrrrruniquerKrrrLrrorr9rrrryrr+rzrr)rlrignore_unobservedrr?rr expected_len result_lenhas_unobserved raise_errrrr rrs ` ``` rnr GroupBy._idxmax_idxmins> s~~ %|yy88,,T2D  s +99D}}}% 151H1H% " " 7748MM4K4KL4KDT&&'4KLL4==**+q0 !8!8!;!K!K!R!R!TU !!;!;< - --'6N->)>)Q>I,,DZi88113D -1   &@@ ((--/333> &tDz':':&;1SEB99"/1  19 WW!$ 3333d4M""% #   }M\ #&(?x$TF*?@CHL$$SE*PP   sJ))*J.. K+8.K&&K+cURRUR5nURS:XaUR UR 5nU$[ U[5(aUR5nURn[ U[R5(de[UR SS9n[ U[5(a@URURR!USUS9UR"UR$S9nU$0n['UR(5H"upxURR!USUS9Xg'M$ URRXaR"S9nUR*UlU$)NrF)compatT) allow_fillrZr)rT)rrMrrrrrrV to_flat_indexrSrr"r:rZrrrVrTrrr"ro) rlrrTr rYrrk column_valuess rnrGroupBy._wrap_idxmax_idxmin sG""499- 88q=ZZ ,F, )%,,++-[[Ffbjj11 11)%++eDH#v&&))KK$$V$R))* (1&(((;$A#kk..%$8/DG)<..t99.E!$ rq) rrrrrrrrrrrr)rrrrrrrrrops.BaseGrouper | Nonerzfrozenset[Hashable] | Noner$rrrrrrrrzbool | lib.NoDefaultrrrr)rr)rr rrrrr)FF)r8rr7r)r rrr)r Series | DataFramerrL)r rrrri)r rr}npt.NDArray[np.float64] | None)rYr r8rr7r)rrL)rr rzdict[np.dtype, Any]rdict[str, bool] | None)rrrr)NFF) rwr rrr8z bool | Noner7rrrrr)FrG)rrrr rrrCallable | None) rrrYrrXr rr rr)NFrG)rrrrrrrr )Fr)rrrrrr)T)r.rrrf)rr )r?rrr)rr)FNN)rrr!Literal['cython', 'numba'] | Nonerr)F)rrrr)rNNF)rsr rrrrrr)NFTFT) rzSequence[Hashable] | Nonerrrrr.rrrrr)rF)rsr rrrrr)FrNN)rrrr rrrr)rrrr rr)FrGNN)FrGT)rrrr r?rrr)rrL)NNN)rrrr_)rrb)rr`)rra)r+zLiteral['ffill', 'bfill']r  int | None)r r)rrS)rzPositionalIndexer | tuplerzLiteral['any', 'all', None]rr)g?rOF)rkzfloat | AnyArrayLiker\rrr)r.r) rrr.rrrrrrAxisInt | lib.NoDefaultrr)rAxis | lib.NoDefaultrr)rrrrrr)rzint | Sequence[int]rrrz str | None)rr rrrr)rr rz$FillnaOptions | None | lib.NoDefaultr zint | None | lib.NoDefaultrr))rr rr)r^znpt.NDArray[np.bool_]rr)rrrZr!r}rrr)NNFNN) rrrz float | NonerrrzSequence | Series | NonerzRandomState | None) rzLiteral['idxmax', 'idxmin']rrrzAxis | None | lib.NoDefaultr?rrrrr)rrrr)]ryrrrrrrrrrorr.rArar?rvryrrrrrrr' _apply_docsrrrzrrrrrrr"r4rr8r(_common_see_alsor rr0rarkrr~rrrr*#_groupby_agg_method_engine_templater r_groupby_agg_method_templaterrrrrrrLrrrrrr-r0rr8rCrFrvrzrrr(rrrr&rrrr=rr*rr=r rrrrqrnrrsAFN %)#'*.15'+),:O :O":O :O ! :O ( :O/:O%:O:O:O:O':O:O :O :Ox   $ 1 1l "'" AA A AF )  2  >   .2'0"'0 +'0 '0Z"'" (( (  (    4++++. +Z ?C!G !GF ?C" "NJ&& 4H(I '  9=?  ?B )-" + + !+ & +  +  +  +  + Z #? #' ???  ?  ? ?$(9(9 )(914(9;C(9 (9T  $" / // /  / /dEF((&*(:A(  -1'< '>>2 > . >U) V>< $   ! 'P Q' R  +    ! )X#4804 2  . U) V2 +    ! )X#4804 2  . U) V2 NRM  M 58M GKM M  M ^ NRB  B 58B GKB B  B H W Wr    #  ##J ;?B  B H I  I V y!   "  $ y!   "  " Q Qf y!Y0" Y0v y!L0" L0\  y!+,X(-" X(z/38 $8,8  8t #&%" a= a=a= a= a=F y!P" Pd 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!+, 9*BGGI,DE v388T:J K I7s: 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.)NrNT) rrMr"rrrrrrrrr)rrUr}znpt.NDArray[np.float64]rrV)r __future__rcollections.abcrrrrr functoolsrr r9textwrapr typingr r r rrrrrnumpyrpandas._config.configr pandas._libsrrpandas._libs.algosrpandas._libs.groupby_libsrmr)pandas._libs.missingrpandas._typingrrrrrrrrrr 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.r/r0r1r2r3r4r5r6r7r8pandas.core.dtypes.missingr9r:r; pandas.corer<r=pandas.core._numbar>pandas.core.applyr?pandas.core.arraysr@rArBrCrDrErFpandas.core.arrays.string_rGpandas.core.arrays.string_arrowrHrIpandas.core.baserJrKpandas.core.commoncorecommonrpandas.core.framerLpandas.core.genericrMpandas.core.groupbyrNrOrPpandas.core.groupby.grouperrQpandas.core.groupby.indexingrRrSpandas.core.indexes.apirTrUrVrWrXpandas.core.internals.blocksrYpandas.core.seriesrZpandas.core.sortingr[pandas.core.util.numba_r\r]r^r r_rr`rarbrrrrr_transform_template_agg_template_series_agg_template_framergr  _KeysArgTyperrrr#rrrrqrnrWs# 0'))#/ 5     (43! '' 4<%6 . AD@B2Iw r 4&'#P5n\|PdM`,2 N hZ !"8*h& '( Hh  ! F,x 8:NFT37C[Ik(#[I|RW#&*   $     8Hrq