Pi 2UdZddlmZddlmZddlmZddlZddlm Z ddl m Z ddl m Z mZmZmZmZmZddlZddlZdd lmZdd lmZdd lmZmZdd lmZdd lm Z ddl!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(ddl)m*Z*m+Z+ddl,m-Z-ddl.m/Z/m0Z0ddl1m2Z2ddl3m4Z4m5Z5m6Z6m7Z7ddl8m9cm:Z;ddlm?Z?ddl@mAZAmBZBddlCmDZDmEZEmFZFmGZGddlHmIZIddlJmKZKddlLmMZMddlNmOZOe r&ddlmPZPmQZQddlRmSZSmTZTmUZUmVZVmWZWmXZXmYZYddlZm[Z[ddl\m]Z]e^ed efzZ_d!e`d"<ed#Zaed$ejbGd%d&Zced'Gd(d)eAeIZded'Gd*d+eAe=Zed3d2ZfdS)4z Define the SeriesGroupBy and DataFrameGroupBy classes that hold the groupby interfaces (and some implementations). These are user facing as the result of the ``df.groupby(...)`` operations, which here returns a DataFrameGroupBy object. ) annotations)abc)CallableN)partial)dedent) TYPE_CHECKINGAnyLiteral TypeAliasTypeVarcast)Interval) duplicated)Pandas4WarningSpecificationError) set_module)find_stack_level) ensure_int64is_bool is_dict_likeis_integer_dtype is_list_likeis_numeric_dtype is_scalar)CategoricalDtype IntervalDtype) is_hashable)isnanotna) algorithms) GroupByApplymaybe_mangle_lambdasreconstruct_funcvalidate_func_kwargs) DataFrame)base)GroupBy GroupByPlot)Index MultiIndexall_indexes_same default_index)Series)get_group_index)maybe_use_numba)boxplot_frame_groupby)HashableSequence) ArrayLike BlockManagerCorrelationMethod IndexLabelManagerSingleBlockManager TakeIndexer) Categorical)NDFrame.r AggScalar ScalarResultpandascreZdZUdZded<ded<dZded<eje Z d ed <ddZ ddZ dS)NamedAgga Helper for column specific aggregation with control over output column names. Parameters ---------- column : Hashable Column label in the DataFrame to apply aggfunc. aggfunc : function or str Function to apply to the provided column. If string, the name of a built-in pandas function. *args, **kwargs : Any Optional positional and keyword arguments passed to ``aggfunc``. See Also -------- DataFrame.groupby : Group DataFrame using a mapper or by a Series of columns. Examples -------- >>> df = pd.DataFrame({"key": [1, 1, 2], "a": [-1, 0, 1], 1: [10, 11, 12]}) >>> agg_a = pd.NamedAgg(column="a", aggfunc="min") >>> agg_1 = pd.NamedAgg(column=1, aggfunc=lambda x: np.mean(x)) >>> df.groupby("key").agg(result_a=agg_a, result_1=agg_1) result_a result_1 key 1 -1 10.5 2 1 12.0 >>> def n_between(ser, low, high, **kwargs): ... return ser.between(low, high, **kwargs).sum() >>> agg_between = pd.NamedAgg("a", n_between, 0, 1) >>> df.groupby("key").agg(count_between=agg_between) count_between key 1 1 2 1 >>> agg_between_kw = pd.NamedAgg("a", n_between, 0, 1, inclusive="both") >>> df.groupby("key").agg(count_between_kw=agg_between_kw) count_between_kw key 1 1 2 1 r1columnr<aggfuncztuple[Any, ...]args)default_factoryzdict[str, Any]kwargsCallable[..., Any] | strr returnNonec>||_||_||_||_dSN)rArBrDrF)selfrArBrDrFs o/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/pandas/core/groupby/generic.py__init__zNamedAgg.__init__s$    keyintc|dkr|jS|dkr|jS|dkr|jS|dkr|jSt d)z/Provide backward-compatible tuple-style access.rzindex out of range)rArBrDrF IndexError)rLrPs rM __getitem__zNamedAgg.__getitem__sU !88;  AXX<  AXX9  AXX; -...rON) rAr1rBrGrDr rFr rHrI)rPrQrHr ) __name__ __module__ __qualname____doc____annotations__rD dataclassesfielddictrFrNrWrCrOrMr@r@ms,,\D.[.tDDDFDDDD     / / / / / /rOr@zpandas.api.typingceZdZd\dZdddd]dZd^fd Zd_ddddZeZdZd`dZ dadbdZ e dZ ddddZ dcddd Zded#Zdfdgd&Zdfdhd(Zdid^fd) Z djdkd-Zdld0Z dmdnd2Z dmdnd3Zedod5Z dpdqd<Z dpdqd=Zdfdrd>Zdfdrd?Z dsdtdFZ dudvdIZed^dJZed^dKZ dwdxdYZ!ed^dZZ"d^d[Z#xZ$S)y SeriesGroupBymgrr7rHr-cj|j||j}|jj|_|SNaxes)obj_constructor_from_mgrrfname_name)rLrbouts rM_wrap_agged_managerz!SeriesGroupBy._wrap_agged_managers.h,,Ssx,@@HM  rOFN numeric_onlyrirnboolri str | Noner8c |j}|j}|rAt|js-d}t d|dt |jd|d|S)Nrnz Cannot use z =True with .z and non-numeric dtypes.)_obj_with_exclusions_mgrrdtype TypeErrortyperX)rLrnrisersinglekwd_names rM_get_data_to_aggregatez$SeriesGroupBy._get_data_to_aggregates'   0 ; ; %HHhHH::&HH)-HHH  rOc>tj|g|Ri|S)aC Apply function ``func`` group-wise and combine the results together. The function passed to ``apply`` must take a series 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 series as its first argument, and returns a dataframe, a series or a scalar. In addition the callable may take positional and keyword arguments. *args : tuple Optional positional arguments to pass to ``func``. **kwargs : dict Optional keyword arguments to pass to ``func``. Returns ------- Series or DataFrame A pandas object with the result of applying ``func`` to each group. 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 ----- 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 -------- >>> 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. 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 )superapply)rLfuncrDrF __class__s rMr~zSeriesGroupBy.applys,Nuww}T3D333F333rOengine engine_kwargsc|du}d}|rt|\}}i}t|tr3t|r|||d<|||d<t |||i|St|t jrTt|}||d<||d<|j|g|Ri|}|r |J||_ |j s| }|St|r|j |g|Rd|i|S|j dkrQ|j} ||jg|jj|jj| jS|j|g|Ri|S)a| Aggregate using one or more operations. The ``aggregate`` method enables flexible and efficient aggregation of grouped data using a variety of functions, including built-in, user-defined, and optimized JIT-compiled functions. Parameters ---------- func : function, str, list or None Function to use for aggregating the data. If a function, must either work when passed a Series or when passed to Series.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. *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 ------- Series Aggregated Series based on the grouping and the applied aggregation functions. See Also -------- SeriesGroupBy.apply : Apply function func group-wise and combine the results together. SeriesGroupBy.transform : Transforms the Series on each group based on the given function. Series.aggregate : Aggregate using one or more operations. 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. The resulting dtype will reflect the return value of the passed ``func``, see the examples below. Examples -------- >>> s = pd.Series([1, 2, 3, 4]) >>> s 0 1 1 2 2 3 3 4 dtype: int64 >>> s.groupby([1, 1, 2, 2]).min() 1 1 2 3 dtype: int64 >>> s.groupby([1, 1, 2, 2]).agg("min") 1 1 2 3 dtype: int64 >>> s.groupby([1, 1, 2, 2]).agg(["min", "max"]) min max 1 1 2 2 3 4 The output column names can be controlled by passing the desired column names and aggregations as keyword arguments. >>> s.groupby([1, 1, 2, 2]).agg( ... minimum="min", ... maximum="max", ... ) minimum maximum 1 1 2 2 3 4 The resulting dtype will reflect the return value of the aggregating function. >>> s.groupby([1, 1, 2, 2]).agg(lambda x: x.astype(float).min()) 1 1.0 2 3.0 dtype: float64 Nrrrriindexru)r$ isinstancestrr/getattrrIterabler"_aggregate_multiple_funcscolumnsas_index reset_index_aggregate_with_numbangroupsrs_wrap_aggregated_outputrg _constructorri_grouper result_indexru_python_agg_general) rLrrrrDrF relabelingrretrgs rM aggregatezSeriesGroupBy.aggregate:s~T\   088MGTF dC . Cv&& *6+= $*x (*7'&74&&777 7 cl + +# C(--D%F8 &3F? #0$0GGGGGGC &***% = (oo''Jv&& 1t1/<@F|q  /33H))!X]"m8!i *,4+DB4BBB6BB BrOcfd}|j}|j||}|||j}||S)Nc|gRiSrKrCxrDrrFs rMz3SeriesGroupBy._python_agg_general..!dd1.t...v..rOri)rsr agg_seriesrrir)rLrrDrFfrgresultress ``` rMrz!SeriesGroupBy._python_agg_generalsf . . . . . .'))#q11vCH55++C000rOr%c&t|trtdtd|Dr d|D}nd|D}t ||d}i}t j|dd5t|D]2\}\}}tj ||} |j |g|Ri||| <3 dddn #1swxYwYtd | Dr2d d l m } | | d d |D} | Sd|D} |j| d} t#d|D| _| S)Nznested renamer is not supportedc3NK|] }t|ttfV!dSrKrtuplelist.0rs rM z:SeriesGroupBy._aggregate_multiple_funcs..s099z!eT]++999999rOc3ZK|]&}t|ttfs||fn|V'dSrKrrs rMrz:SeriesGroupBy._aggregate_multiple_funcs..s=RRAt}!=!=DAq661RRRRRRrOc3BK|]}tj|p|VdSrK)comget_callable_name)rrs rMrz:SeriesGroupBy._aggregate_multiple_funcs..s2BBs,Q//41BBBBBBrOT)strictr)labelpositionc3@K|]}t|tVdSrK)rr%rs rMrz:SeriesGroupBy._aggregate_multiple_funcs.. s,BBAz!Y''BBBBBBrOrconcatrScg|] }|j SrCrrrPs rM z;SeriesGroupBy._aggregate_multiple_funcs..s/M/M/Mc /M/M/MrO)axiskeysc$i|] \}}|j|SrC)r)rrPvals rM z;SeriesGroupBy._aggregate_multiple_funcs..s LLLS#,LLLrOrc3$K|] }|jV dSrKrrs rMrz:SeriesGroupBy._aggregate_multiple_funcs..s$<ritemsrg_constructor_expanddimr)r)rLargrDrFrresultsidxrirrPrres_dfindexed_outputoutputs rMrz'SeriesGroupBy._aggregate_multiple_funcss7 c4  H$%FGG G 99S999 9 9 1RRcRRRCCCBcBBBGgs4000C<>  dJ 5 5 E E&/s^^ E E!\dDn4#>>>-t~dDTDDDVDD  E E E E E E E E E E E E E E E E BB1A1ABBB B B  % % % % % %V  q/M/MW/M/M/MFMLLGMMOOLLL00t0LL<>> ser = pd.Series([390.0, 350.0, 30.0, 20.0], ... index=["Falcon", "Falcon", "Parrot", "Parrot"], ... name="Max Speed") >>> grouped = ser.groupby([1, 1, 2, 2]) >>> grouped.transform(lambda x: (x - x.mean()) / x.std()) Falcon 0.707107 Falcon -0.707107 Parrot 0.707107 Parrot -0.707107 Name: Max Speed, dtype: float64 Broadcast result of the transformation >>> grouped.transform(lambda x: x.max() - x.min()) Falcon 40.0 Falcon 40.0 Parrot 10.0 Parrot 10.0 Name: Max Speed, dtype: float64 >>> grouped.transform("mean") Falcon 370.0 Falcon 370.0 Parrot 25.0 Parrot 25.0 Name: Max Speed, dtype: float64 The resulting dtype will reflect the return value of the passed ``func``, for example: >>> grouped.transform(lambda x: x.astype(int).max()) Falcon 390 Falcon 390 Parrot 30 Parrot 30 Name: Max Speed, dtype: int64 c*|j|g|R||d|S)a Call function producing a same-indexed Series on each group. Returns a Series having the same indexes as the original object filled with the transformed values. Parameters ---------- func : 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 ------- Series Series with the same indexes as the original object filled with transformed values. See Also -------- Series.groupby.apply : Apply function ``func`` group-wise and combine the results together. Series.groupby.aggregate : Aggregate using one or more operations. Series.transform : Call ``func`` on self producing a Series 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. 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 -------- >>> ser = pd.Series( ... [390.0, 350.0, 30.0, 20.0], ... index=["Falcon", "Falcon", "Parrot", "Parrot"], ... name="Max Speed", ... ) >>> grouped = ser.groupby([1, 1, 2, 2]) >>> grouped.transform(lambda x: (x - x.mean()) / x.std()) Falcon 0.707107 Falcon -0.707107 Parrot 0.707107 Parrot -0.707107 Name: Max Speed, dtype: float64 Broadcast result of the transformation >>> grouped.transform(lambda x: x.max() - x.min()) Falcon 40.0 Falcon 40.0 Parrot 10.0 Parrot 10.0 Name: Max Speed, dtype: float64 >>> grouped.transform("mean") Falcon 370.0 Falcon 370.0 Parrot 25.0 Parrot 25.0 Name: Max Speed, dtype: float64 The resulting dtype will reflect the return value of the passed ``func``, for example: >>> grouped.transform(lambda x: x.astype(int).max()) Falcon 390 Falcon 390 Parrot 30 Parrot 30 Name: Max Speed, dtype: int64 r _transformrLrrrrDrFs rM transformzSeriesGroupBy.transformsBNt    &m  GM   rOhowrc |j} |jjd|j|dfi|}n-#t$r }t |d|jd|d}~wwxYw|||jj |j S)Nrrz is not supported for z dtyperri) rsr_cython_operation_valuesNotImplementedErrorrvrurrgrri)rLrrnrFrgrerrs rM_cython_transformzSeriesGroupBy._cython_transforms' V4T]4S[#q4:FF# V V VsKK#)KKKLLRU U Vdhn38LLLs% AA  Arrc>t|r|j|g|Rd|i|St|sJt|j}g}|j|jD]R\}} t | d||| g|Ri|} | || | j S|r)ddl m } | |d} || } n%|jt j} |jj| _| S) z3 Transform with a callable `func`. rrirrrT) ignore_indexru)r/_transform_with_numbacallablerwrgr get_iteratorrsobject __setattr__appendrpandas.core.reshape.concatr_set_result_index_orderedrnpfloat64ri)rLrrrrDrFklassrrigrouprr concatenatedrs rM_transform_generalz SeriesGroupBy._transform_general#sn 6 " " -4-+8>> df = pd.DataFrame( ... { ... "A": ["foo", "bar", "foo", "bar", "foo", "bar"], ... "B": [1, 2, 3, 4, 5, 6], ... "C": [2.0, 5.0, 8.0, 1.0, 2.0, 9.0], ... } ... ) >>> grouped = df.groupby("A") >>> df.groupby("A").B.filter(lambda x: x.mean() > 3.0) 1 2 3 4 5 6 Name: B, dtype: int64 c0t|iSrKrrs rMrz&SeriesGroupBy.filter..zs! 04 0 0$ A& A ArOc|gRiSrKrCrs rMrz&SeriesGroupBy.filter..|s!Q 8 8 8 8 8 8rOrHroc<|}t|o|SrK)r)rbwrappers rMtrue_and_notnaz,SeriesGroupBy.filter..true_and_notnas  A88> !rOcVg|]%\}}||&SrC) _get_index)rrirrLrs rMrz(SeriesGroupBy.filter..sID%!>%((%%rOz'the filter must return a boolean resultN)rHro)rrrrrs ValueErrorrv _apply_filter) rLrrrDrFindicesrfilteredrrs `` `` @@rMfilterzSeriesGroupBy.filterFsf dC  9AAAAAAGG888888G " " " " " " P#'=#=#=d>W#X#XGG I& P P PEFFC O P%%gv66s,AB0BBSeries | DataFramec|jj}|jj}|jj}t j||d\}}|jjr|dk}||}||}t||g|t|fd|}|r+|dk}| r||}||}t|d}tj |||} t| } |jj} |j| | |jj} |js6|| } t)t| | _| S)a Return number of unique elements in the group. Parameters ---------- dropna : bool, default True Don't include NaN in the counts. Returns ------- Series Number of unique values within each group. See Also -------- core.resample.Resampler.nunique : Method nunique for Resampler. Examples -------- >>> lst = ["a", "a", "b", "b"] >>> ser = pd.Series([1, 2, 3, 3], index=lst) >>> ser a 1 a 2 b 3 b 3 dtype: int64 >>> ser.groupby(level=0).nunique() a 2 b 1 dtype: int64 F)use_na_sentinelsortr)labelsshaperxnullfirst) minlengthr)ridsrrgrr factorizehas_dropped_nar.rrrrbincountrrrrirrr,r) rLrrrrcodesuniquesmask group_indexrrirs rMnuniquezSeriesGroupBy.nuniquesoBm-'h#-c6PUVVVw = ' !8Dd)C$KE%<CLL)      0!#D{{}} 0$i)$/ +w//k#te*8883 ] '%)X%:%: r &;& & } 60088F(V55FL rOcLt|||S)a< Generate descriptive statistics. Descriptive statistics include those that summarize the central tendency, dispersion and shape of a dataset's distribution, excluding ``NaN`` values. Analyzes both numeric and object series, as well as ``DataFrame`` column sets of mixed data types. The output will vary depending on what is provided. Refer to the notes below for more detail. Parameters ---------- percentiles : list-like of numbers, optional The percentiles to include in the output. All should fall between 0 and 1. The default, ``None``, will automatically return the 25th, 50th, and 75th percentiles. include : 'all', list-like of dtypes or None (default), optional A white list of data types to include in the result. Ignored for ``Series``. Here are the options: - 'all' : All columns of the input will be included in the output. - A list-like of dtypes : Limits the results to the provided data types. To limit the result to numeric types submit ``numpy.number``. To limit it instead to object columns submit the ``numpy.object`` data type. Strings can also be used in the style of ``select_dtypes`` (e.g. ``df.describe(include=['O'])``). To select pandas categorical columns, use ``'category'`` - None (default) : The result will include all numeric columns. exclude : list-like of dtypes or None (default), optional, A black list of data types to omit from the result. Ignored for ``Series``. Here are the options: - A list-like of dtypes : Excludes the provided data types from the result. To exclude numeric types submit ``numpy.number``. To exclude object columns submit the data type ``numpy.object``. Strings can also be used in the style of ``select_dtypes`` (e.g. ``df.describe(exclude=['O'])``). To exclude pandas categorical columns, use ``'category'`` - None (default) : The result will exclude nothing. Returns ------- Series or DataFrame Summary statistics of the Series or Dataframe provided. See Also -------- DataFrame.count: Count number of non-NA/null observations. DataFrame.max: Maximum of the values in the object. DataFrame.min: Minimum of the values in the object. DataFrame.mean: Mean of the values. DataFrame.std: Standard deviation of the observations. DataFrame.select_dtypes: Subset of a DataFrame including/excluding columns based on their dtype. Notes ----- For numeric data, the result's index will include ``count``, ``mean``, ``std``, ``min``, ``max`` as well as lower, ``50`` and upper percentiles. By default the lower percentile is ``25`` and the upper percentile is ``75``. The ``50`` percentile is the same as the median. For object data (e.g. strings), the result's index will include ``count``, ``unique``, ``top``, and ``freq``. The ``top`` is the most common value. The ``freq`` is the most common value's frequency. If multiple object values have the highest count, then the ``count`` and ``top`` results will be arbitrarily chosen from among those with the highest count. For mixed data types provided via a ``DataFrame``, the default is to return only an analysis of numeric columns. If the DataFrame consists only of object and categorical data without any numeric columns, the default is to return an analysis of both the object and categorical columns. If ``include='all'`` is provided as an option, the result will include a union of attributes of each type. The `include` and `exclude` parameters can be used to limit which columns in a ``DataFrame`` are analyzed for the output. The parameters are ignored when analyzing a ``Series``. Examples -------- Describing a numeric ``Series``. >>> s = pd.Series([1, 2, 3, 4]) >>> s 0 1 1 2 2 3 3 4 dtype: int64 >>> s.groupby([1, 1, 2, 2]).describe() count mean std min 25% 50% 75% max 1 2.0 1.5 0.707107 1.0 1.25 1.5 1.75 2.0 2 2.0 3.5 0.707107 3.0 3.25 3.5 3.75 4.0 ) percentilesincludeexclude)r}describe)rLr$r%r&rs rMr'zSeriesGroupBy.describes.Tww#Wg    rO normalizer ascendingc &'()*|rdnd}|"|||||}||_|Sddlm}ddlm} |jj} |jj } g|jj |jj} t| j ts|Mtj|s9|t"j||||} || _| | j_ | S| d k(| (| (} } |t)j| d \}}d }n^| t#| d |d }t-d|j }|j}||jd |j}d}t|j t6r7t-t8|}tj|j|j| f}ntj|| f}| |||}} dtj | dd| dd kdz}tj!d|f}tE| s|}||tGdd||tGdd k}tj!d |f}tE| s|}d ||<tj$tj tj!|d fd}tKtj&tj'(||*t|jj)tTrtW|jj)j}n>> s = pd.Series( ... [1, 1, 2, 3, 2, 3, 3, 1, 1, 3, 3, 3], ... index=["A", "A", "A", "A", "A", "A", "B", "B", "B", "B", "B", "B"], ... ) >>> s A 1 A 1 A 2 A 3 A 2 A 3 B 3 B 1 B 1 B 3 B 3 B 3 dtype: int64 >>> g1 = s.groupby(s.index) >>> g1.value_counts(bins=2) A (0.997, 2.0] 4 (2.0, 3.0] 2 B (2.0, 3.0] 4 (0.997, 2.0] 2 Name: count, dtype: int64 >>> g1.value_counts(normalize=True) A 1 0.333333 2 0.333333 3 0.333333 B 3 0.666667 1 0.333333 Name: proportion, dtype: float64 proportioncountN)r(rr)rr)get_join_indexers)cut)r(rr)binsT)rc||SrKrClabincs rMrz,SeriesGroupBy.value_counts..s CHrOF)copy)include_lowestr:) allow_fill fill_valuec2||jjdS)Nr0) _multiindexrr2s rMrz,SeriesGroupBy.value_counts..sCH$8$>r$BrOrS)repeats)rrc&g|] }|SrCrC)r level_codesreps rMrz.SeriesGroupBy.value_counts..s#;;;k[!!;;;rOc g|] }| SrCrC)rr=rs rMrz.SeriesGroupBy.value_counts..s(T(T(T{T):(T(T(TrOfloatrorleft)rr lev_codes np.ndarrayrHc:tj|SrK)rrepeat)rBdiffnbins rM build_codesz/SeriesGroupBy.value_counts..build_codes+sy4$777rOc&g|] }|SrCrC)rrBrHs rMrz.SeriesGroupBy.value_counts...s#HHH [[++HHHrO)levelsrnamesverify_integrityr)rBrCrHrC)> _value_countsripandas.core.reshape.merger-pandas.core.reshape.tiler.rrrgrrKrrurriterabler~r- value_countsrr rr categoriestaker _na_valuerrlexsortrArightnonzeror_rslicerFrrEaddreduceatrr*r_sortrrJallastypeatzerossumarangetilecumsumwhererrrrrr)+rLr(rr)r/rrirr-r.rr index_namesrxr3levllabcat_sercat_obj lab_intervalsorter idchangesrlchangesr4rkrrJdmacccatr=ncatrArV_mirHrFrrGr>s+ @@@@@rMrQzSeriesGroupBy.value_countsBsSj )5||g <''#$)F(FFKM??????000000mh; +;TX]; ci!1 2 2   R[%6%6  **### CCH)CIOJbyt9c$iS <!+Cd;;;HC,,DDc&51114MMMG='/::G$C(( =C CBD ci / / ,#..LZ!2L4F LMMFFZc ++Fv;F S 3qrr7c#2#h#677:: eAyL!3xx C4U1d^^,,S%b//0J0JJeD(N#3xx CCgbjsDy!1221566bic)B)BCCC dm0* = = 39::EE$M.,$(M$8 E<;;;U;;;ttC~~>NN-4='--  U9?Dxxzz U Y(T(T(T(Te(T(T(TU  **W%%Cc3s88m,--A r N !Q###c!ffTlc!ff 3JC  I%?SSC4a$IJJ #F T"Xf-= T"X 8 8 8 8 8 8 8IHHHU3B3ZHHHE LLb " " " kE    CI & & $s##C&&s"4&@@} *''))F rOr r9c $|jdd|i|}|S)a Return the elements in the given *positional* indices in each group. This means that we are not indexing according to actual values in the index attribute of the object. We are indexing according to the actual position of the element in the object. If a requested index does not exist for some group, this method will raise. To get similar behavior that ignores indices that don't exist, see :meth:`.SeriesGroupBy.nth`. Parameters ---------- indices : array-like An array of ints indicating which positions to take in each group. **kwargs For compatibility with :meth:`numpy.take`. Has no effect on the output. Returns ------- Series A Series containing the elements taken from each group. See Also -------- Series.take : Take elements from a Series along an axis. Series.loc : Select a subset of a DataFrame by labels. Series.iloc : Select a subset of a DataFrame by positions. numpy.take : Take elements from an array along an axis. SeriesGroupBy.nth : Similar to take, won't raise if indices don't exist. Examples -------- >>> df = pd.DataFrame( ... [ ... ("falcon", "bird", 389.0), ... ("parrot", "bird", 24.0), ... ("lion", "mammal", 80.5), ... ("monkey", "mammal", np.nan), ... ("rabbit", "mammal", 15.0), ... ], ... columns=["name", "class", "max_speed"], ... index=[4, 3, 2, 1, 0], ... ) >>> df name class max_speed 4 falcon bird 389.0 3 parrot bird 24.0 2 lion mammal 80.5 1 monkey mammal NaN 0 rabbit mammal 15.0 >>> gb = df["name"].groupby([1, 1, 2, 2, 2]) Take elements at rows 0 and 1 in each group. >>> gb.take([0, 1]) 1 4 falcon 3 parrot 2 2 lion 1 monkey Name: name, dtype: str We may take elements using negative integers for positive indices, starting from the end of the object, just like with Python lists. >>> gb.take([-1, -2]) 1 3 parrot 4 falcon 2 0 rabbit 1 monkey Name: name, dtype: str rSr rS _op_via_applyrLr rFrs rMrSzSeriesGroupBy.take<s'^$#FFGFvFF rOskipnac &|j dd||d|S)a Return unbiased skew within groups. Normalized by N-1. Parameters ---------- skipna : bool, default True Exclude NA/null values when computing the result. numeric_only : bool, default False Include only float, int, boolean columns. Not implemented for Series. **kwargs Additional keyword arguments to be passed to the function. Returns ------- Series Unbiased skew within groups. See Also -------- Series.skew : Return unbiased skew over requested axis. Examples -------- >>> ser = pd.Series( ... [390.0, 350.0, 357.0, np.nan, 22.0, 20.0, 30.0], ... index=[ ... "Falcon", ... "Falcon", ... "Falcon", ... "Falcon", ... "Parrot", ... "Parrot", ... "Parrot", ... ], ... name="Max Speed", ... ) >>> ser Falcon 390.0 Falcon 350.0 Falcon 357.0 Falcon NaN Parrot 22.0 Parrot 20.0 Parrot 30.0 Name: Max Speed, dtype: float64 >>> ser.groupby(level=0).skew() Falcon 1.525174 Parrot 1.457863 Name: Max Speed, dtype: float64 >>> ser.groupby(level=0).skew(skipna=False) Falcon NaN Parrot 1.457863 Name: Max Speed, dtype: float64 skewNaltr{rnr}_cython_agg_generalrLr{rnrFs rMr}zSeriesGroupBy.skews8B(t'  V,  JP   rOc ,d}|j d|||d|S)a Return unbiased kurtosis within groups. Parameters ---------- skipna : bool, default True Exclude NA/null values when computing the result. numeric_only : bool, default False Include only float, int, boolean columns. Not implemented for Series. **kwargs Additional keyword arguments to be passed to the function. Returns ------- Series Unbiased kurtosis within groups. See Also -------- Series.kurt : Return unbiased kurtosis over requested axis. Examples -------- >>> ser = pd.Series( ... [390.0, 350.0, 357.0, 333.0, np.nan, 22.0, 20.0, 30.0, 40.0, 41.0], ... index=[ ... "Falcon", ... "Falcon", ... "Falcon", ... "Falcon", ... "Falcon", ... "Parrot", ... "Parrot", ... "Parrot", ... "Parrot", ... "Parrot", ... ], ... name="Max Speed", ... ) >>> ser Falcon 390.0 Falcon 350.0 Falcon 357.0 Falcon 333.0 Falcon NaN Parrot 22.0 Parrot 20.0 Parrot 30.0 Parrot 40.0 Parrot 41.0 Name: Max Speed, dtype: float64 >>> ser.groupby(level=0).kurt() Falcon 1.622109 Parrot -2.878714 Name: Max Speed, dtype: float64 >>> ser.groupby(level=0).kurt(skipna=False) Falcon NaN Parrot -2.878714 Name: Max Speed, dtype: float64 c0td|j)Nz"'kurt' is not supported for dtype=rvrurgs rMrzSeriesGroupBy.kurt..altLLLMM MrOkurtr~rrrLr{rnrFrs rMrzSeriesGroupBy.kurtsJJ N N N (t'  F  IO   rOr(c$t|}|S)a5 Make plots of groups from a Series. Uses the backend specified by the option ``plotting.backend``. By default, matplotlib is used. Returns ------- GroupByPlot A plotting object that can be used to create plots for each group. See Also -------- Series.plot : Make plots of Series. Examples -------- >>> ser = pd.Series([1, 2, 3, 4, 5], index=["a", "a", "b", "b", "c"]) >>> g = ser.groupby(level=0) >>> g.plot() # doctest: +SKIP r(rLrs rMplotzSeriesGroupBy.plot!s.T"" rOrnrQkeepLiteral['first', 'last', 'all']c|ttj||}|j}|||d}|S)a Return the largest `n` elements. Parameters ---------- n : int, default 5 Return this many descending sorted values. keep : {'first', 'last', 'all'}, default 'first' When there are duplicate values that cannot all fit in a Series of `n` elements: - ``first`` : return the first `n` occurrences in order of appearance. - ``last`` : return the last `n` occurrences in reverse order of appearance. - ``all`` : keep all occurrences. This can result in a Series of size larger than `n`. Returns ------- Series The `n` largest values in the Series, sorted in decreasing order. See Also -------- Series.nsmallest: Get the `n` smallest elements. Series.sort_values: Sort Series by values. Series.head: Return the first `n` rows. Notes ----- Faster than ``.sort_values(ascending=False).head(n)`` for small `n` relative to the size of the ``Series`` object. Examples -------- >>> s = pd.Series([1, 2, 3, 4, 5, 6]) >>> s 0 1 1 2 2 3 3 4 4 5 5 6 dtype: int64 >>> s.groupby([1, 1, 1, 2, 2, 2]).nlargest(n=2) 1 2 3 1 2 2 5 6 4 5 dtype: int64 rrTr)rr-nlargestrs_python_apply_generalrLrrrrrs rMrzSeriesGroupBy.nlargest;sDr FOqt 4 4 4(++Atd+KK rOc|ttj||}|j}|||d}|S)a Return the smallest `n` elements. Parameters ---------- n : int, default 5 Return this many ascending sorted values. keep : {'first', 'last', 'all'}, default 'first' When there are duplicate values that cannot all fit in a Series of `n` elements: - ``first`` : return the first `n` occurrences in order of appearance. - ``last`` : return the last `n` occurrences in reverse order of appearance. - ``all`` : keep all occurrences. This can result in a Series of size larger than `n`. Returns ------- Series The `n` smallest values in the Series, sorted in increasing order. See Also -------- Series.nlargest: Get the `n` largest elements. Series.sort_values: Sort Series by values. Series.head: Return the first `n` rows. Notes ----- Faster than ``.sort_values().head(n)`` for small `n` relative to the size of the ``Series`` object. Examples -------- >>> s = pd.Series([1, 2, 3, 4, 5, 6]) >>> s 0 1 1 2 2 3 3 4 4 5 5 6 dtype: int64 >>> s.groupby([1, 1, 1, 2, 2, 2]).nsmallest(n=2) 1 0 1 1 2 2 3 4 4 5 dtype: int64 rTr)rr- nsmallestrsrrs rMrzSeriesGroupBy.nsmallest{sEr F$ 5 5 5(++Atd+KK rOc0|d|S)a Return the row label of the minimum value. If multiple values equal the minimum, the first row label with that value is returned. Parameters ---------- skipna : bool, default True Exclude NA values. Returns ------- Series Indexes of minima in each group. Raises ------ ValueError When there are no valid values for a group. Then can happen if: * There is an unobserved group and ``observed=False``. * All values for a group are NA. * Some values for a group are NA and ``skipna=False``. .. versionchanged:: 3.0.0 Previously if all values for a group are NA or some values for a group are NA and ``skipna=False``, this method would return NA. Now it raises instead. See Also -------- numpy.argmin : Return indices of the minimum values along the given axis. DataFrame.idxmin : Return index of first occurrence of minimum over requested axis. Series.idxmax : Return index *label* of the first occurrence of maximum of values. Examples -------- >>> 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.groupby(["a", "a", "b", "b"]).idxmin() a 2023-01-01 b 2023-02-01 dtype: datetime64[us] idxminr{_idxmax_idxminrLr{s rMrzSeriesGroupBy.idxminv""8F";;;rOc0|d|S)a Return the row label of the maximum value. If multiple values equal the maximum, the first row label with that value is returned. Parameters ---------- skipna : bool, default True Exclude NA values. Returns ------- Series Indexes of maxima in each group. Raises ------ ValueError When there are no valid values for a group. Then can happen if: * There is an unobserved group and ``observed=False``. * All values for a group are NA. * Some values for a group are NA and ``skipna=False``. .. versionchanged:: 3.0.0 Previously if all values for a group are NA or some values for a group are NA and ``skipna=False``, this method would return NA. Now it raises instead. See Also -------- numpy.argmax : Return indices of the maximum values along the given axis. DataFrame.idxmax : Return index of first occurrence of maximum over requested axis. Series.idxmin : Return index *label* of the first occurrence of minimum of values. Examples -------- >>> 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.groupby(["a", "a", "b", "b"]).idxmax() a 2023-01-15 b 2023-02-15 dtype: datetime64[us] idxmaxrrrs rMrzSeriesGroupBy.idxmaxrrOpearsonotherrr5 min_periods int | Nonec8|d|||}|S)a! Compute correlation between each group and another Series. Parameters ---------- other : Series Series to compute correlation with. method : {'pearson', 'kendall', 'spearman'}, default 'pearson' Method of correlation to use. min_periods : int, optional Minimum number of observations required per pair of columns to have a valid result. Returns ------- Series Correlation value for each group. See Also -------- Series.corr : Equivalent method on ``Series``. Examples -------- >>> s = pd.Series([1, 2, 3, 4], index=[0, 0, 1, 1]) >>> g = s.groupby([0, 0, 1, 1]) >>> g.corr() # doctest: +SKIP corr)rrrrx)rLrrrrs rMrzSeriesGroupBy.corr5s/D## %K$   rOrSddofc8|d|||}|S)a Compute covariance between each group and another Series. Parameters ---------- other : Series Series to compute covariance with. min_periods : int, optional Minimum number of observations required per pair of columns to have a valid result. ddof : int, optional Delta degrees of freedom for variance calculation. Returns ------- Series Covariance value for each group. See Also -------- Series.cov : Equivalent method on ``Series``. Examples -------- >>> s = pd.Series([1, 2, 3, 4], index=[0, 0, 1, 1]) >>> g = s.groupby([0, 0, 1, 1]) >>> g.cov() # doctest: +SKIP cov)rrrrx)rLrrrrs rMrzSeriesGroupBy.cov\s.>## Kd$   rOc.|dS)a Return whether each group's values are monotonically increasing. Returns ------- Series See Also -------- SeriesGroupBy.is_monotonic_decreasing : Return whether each group's values are monotonically decreasing. Examples -------- >>> s = pd.Series([2, 1, 3, 4], index=["Falcon", "Falcon", "Parrot", "Parrot"]) >>> s.groupby(level=0).is_monotonic_increasing Falcon False Parrot True dtype: bool c|jSrK)is_monotonic_increasingrxs rMrz7SeriesGroupBy.is_monotonic_increasing.. c&ArOr~rLs rMrz%SeriesGroupBy.is_monotonic_increasing,zzAABBBrOc.|dS)a Return whether each group's values are monotonically decreasing. Returns ------- Series See Also -------- SeriesGroupBy.is_monotonic_increasing : Return whether each group's values are monotonically increasing. Examples -------- >>> s = pd.Series([2, 1, 3, 4], index=["Falcon", "Falcon", "Parrot", "Parrot"]) >>> s.groupby(level=0).is_monotonic_decreasing Falcon True Parrot False dtype: bool c|jSrK)is_monotonic_decreasingrs rMrz7SeriesGroupBy.is_monotonic_decreasing..rrOrrs rMrz%SeriesGroupBy.is_monotonic_decreasingrrO grid xlabelsizexrot float | None ylabelsizeyrotfigsizetuple[float, float] | Noner/int | Sequence[int]backendlegendc  :|j d||||||||| | | d | } | S)a1 Draw histogram for each group's values using :meth:`Series.hist` API. Parameters ---------- by : object, optional Grouping key. ax : matplotlib.axes.Axes, optional Axis to draw the histogram on. grid : bool, default True Show axis grid lines. xlabelsize : int, default None X axis label size. xrot : float, default None Rotation for x ticks. ylabelsize : int, default None Y axis label size. yrot : float, default None Rotation for y ticks. figsize : tuple, optional Figure size in inches. bins : int or sequence, default 10 Number of histogram bins or bin edges. backend : str or callable or None, optional Plotting backend to use (e.g. 'matplotlib'). If None, use the default plotting backend. legend : bool, default False Whether to draw the legend. **kwargs Additional keyword arguments passed to :meth:`Series.hist`. Returns ------- matplotlib.axes.Axes or ndarray of Axes The returned matplotlib axes or array of axes depending on input. See Also -------- Series.hist : Equivalent histogram plotting method on Series. Examples -------- >>> df = pd.DataFrame({"val": [1, 2, 2, 3, 3, 3]}, index=[0, 0, 1, 1, 2, 2]) >>> g = df["val"].groupby([0, 0, 1, 1, 2, 2]) >>> g.hist() # doctest: +SKIP hist) byaxrrrrrrr/rrrrx)rLrrrrrrrrr/rrrFrs rMrzSeriesGroupBy.histsXz$#  !!     rOc.|dS)z Return the dtype object of the underlying data for each group. Mirrors :meth:`Series.dtype` applied group-wise. Returns ------- Series Dtype of each group's values. c|jSrKrrs rMrz%SeriesGroupBy.dtype.. scirOrrs rMruzSeriesGroupBy.dtypeszz//000rOc0|d}|S)ad Return unique values for each group. It returns unique values for each of the grouped values. Returned in order of appearance. Hash table-based unique, therefore does NOT sort. Returns ------- Series Unique values for each of the grouped values. See Also -------- Series.unique : Return unique values of Series object. Examples -------- >>> df = pd.DataFrame( ... [ ... ("Chihuahua", "dog", 6.1), ... ("Beagle", "dog", 15.2), ... ("Chihuahua", "dog", 6.9), ... ("Persian", "cat", 9.2), ... ("Chihuahua", "dog", 7), ... ("Persian", "cat", 8.8), ... ], ... columns=["breed", "animal", "height_in"], ... ) >>> df breed animal height_in 0 Chihuahua dog 6.1 1 Beagle dog 15.2 2 Chihuahua dog 6.9 3 Persian cat 9.2 4 Chihuahua dog 7.0 5 Persian cat 8.8 >>> ser = df.groupby("animal")["breed"].unique() >>> ser animal cat [Persian] dog [Chihuahua, Beagle] Name: breed, dtype: object uniquerxrs rMrzSeriesGroupBy.unique sX##H-- rO)rbr7rHr-)rnrorirprHr8)rHr-rKrHr%FF) rr-rrrrorrorHrF)rrrnro)rrrHr-T)rro)rrorHr)NNN)FTFNT) r(rorror)rorrorHr)r r9rHr-TF)r{rornrorHr-rHr()rr)rrQrrrHr-)r{rorHr-)rN)rr-rr5rrrHr-NrS)rr-rrrrrHr-) NNTNNNNNrNF)rrorrrrrrrrrrr/rrrprro)%rXrYrZrlr{r~raggrrrr#_SeriesGroupBy__examples_series_docrrrrr"r'rQrSr}rpropertyrrrrrrrrrrrur __classcell__rs@rMraras  ',      g4g4g4g4g4g4RsCTsCsCsCsCsCj C111J"'" FCFCFCFCFCP#F% ''R-1I I I I I V M M M M M!!!!FGGGGGRCCCCCJl l l l l l l `   xxxxxtPPPPh"C C C C C N"L L L L L \X4CJ>>>>>BCJ>>>>>@;<;<;<;<;Z drdsd?Z drdsd@ZedwdBZ dxdydHZ! dzd{dKZ" d|d}d_Z# d~ddcZ$xZ%S)DataFrameGroupByNrcPt|fi|\}}}}t|}t|r ||d<||d<t||||} | } t |s.| ,|js#t|r| S| S|rBtt| } | j dd|f} tt| } || _ | d|vr|d=|d=t|r|j |g|Rd|i|S|jjdkr|j|g|Ri|S|s|r|j|g|Ri|} nt||gdi} | } tt| } |jj | _ n>#t($r1} dt+| vr||} Yd} ~ nd} ~ wwxYw|js6|| } t/t1| | _| S)a Aggregate using one or more operations. The ``aggregate`` function allows the application of one or more aggregation operations on groups of data within a DataFrameGroupBy object. It supports various aggregation methods, including user-defined functions and predefined functions such as 'sum', 'mean', etc. Parameters ---------- func : function, str, list, dict or None Function to use for aggregating the data. If a function, must either work when passed a DataFrame or when passed to DataFrame.apply. Accepted combinations are: - function - string function name - list of functions and/or function names, e.g. ``[np.sum, 'mean']`` - dict of index 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 ------- DataFrame Aggregated DataFrame based on the grouping and the applied aggregation functions. See Also -------- DataFrame.groupby.apply : Apply function func group-wise and combine the results together. DataFrame.groupby.transform : Transforms the Series on each group based on the given function. DataFrame.aggregate : Aggregate using one or more operations. 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. The resulting dtype will reflect the return value of the passed ``func``, see the examples below. Examples -------- >>> data = { ... "A": [1, 1, 2, 2], ... "B": [1, 2, 3, 4], ... "C": [0.362838, 0.227877, 1.267767, -0.562860], ... } >>> df = pd.DataFrame(data) >>> df A B C 0 1 1 0.362838 1 1 2 0.227877 2 2 3 1.267767 3 2 4 -0.562860 The aggregation is for each column. >>> df.groupby("A").agg("min") B C A 1 1 0.227877 2 3 -0.562860 Multiple aggregations >>> df.groupby("A").agg(["min", "max"]) B C min max min max A 1 1 2 0.227877 0.362838 2 3 4 -0.562860 1.267767 Select a column for aggregation >>> df.groupby("A").B.agg(["min", "max"]) min max A 1 1 2 2 3 4 User-defined function for aggregation >>> df.groupby("A").agg(lambda x: sum(x) + 2) B C A 1 5 2.590715 2 9 2.704907 Different aggregations per column >>> df.groupby("A").agg({"B": ["min", "max"], "C": "sum"}) B C min max sum A 1 1 2 0.590715 2 3 4 0.704907 To control the output names with different aggregations per column, pandas supports "named aggregation" >>> df.groupby("A").agg( ... b_min=pd.NamedAgg(column="B", aggfunc="min"), ... c_sum=pd.NamedAgg(column="C", aggfunc="sum"), ... ) b_min c_sum A 1 1 0.590715 2 3 0.704907 - The keywords are the *output* column names - The values are tuples whose first element is the column to select and the second element is the aggregation to apply to that column. Pandas provides the ``pandas.NamedAgg`` namedtuple with the fields ``['column', 'aggfunc']`` to make it clearer what the arguments are. As usual, the aggregation can be a callable or a string alias. See :ref:`groupby.aggregate.named` for more. The resulting dtype will reflect the return value of the aggregating function. >>> df.groupby("A")[["B"]].agg(lambda x: x.astype(float).min()) B A 1 1.0 2 3.0 rr)rDrFNrSrCzNo objects to concatenate)r#r"r/r!rrrrrr r%ilocrrrnkeysr_aggregate_framersr5r rrr,rr) rLrrrrDrFrrorderoprgbars rMrzDataFrameGroupBy.aggregate>sV,6!!8$?+v&& 1t1/<@F}"Q&&/t/FtFFFvFFF N N/.tEdEEEfEE#4$bDDDN WWYYF ")V44F%)%>%F%K%K%M%MFNN" 9 9 92#c((BB"22488FFFFFF 9"} 60088F(V55FL sF++ G&5'G!!G&cfd}|jdkr|||jdS|j}t |js|||jSi}t |D](\}\}} |j | |} | ||<)|j |} |j d| _| | S)Nc|gRiSrKrCrs rMrz6DataFrameGroupBy._python_agg_general..; rrOrT)is_aggF)deep)rr _selected_objrsrrrrrrrgrr5r) rLrrDrFrrgrrrirxrrs ``` rMrz$DataFrameGroupBy._python_agg_general: s  . . . . . . <1  --a1CD-QQ Q'3; E--a1CDD D') )#))++ 6 6 ! ! C$]--c155F F3KKh##F++k&&E&22 ++C000rOrHr%c"|jjdkrtd|j}i}|j|D]\}}||g|Ri|}|||<|jj} |j||j| } | j } | S)NrSzNumber of keys must be 1rr) rrAssertionErrorrsrrrgrrT) rLrrDrFrgrrigrp_dffresrrks rMrz!DataFrameGroupBy._aggregate_frameQ s = ! # # !;<< <'79 M66s;;  LD&4000000DF4LL}1 h##F#+|#TTe rOFrrrrrorc t|dkr]|r|j}n|jsd}n |jj}|j||j}||j }|Sttj |d}|<|j|j}||j }|St|tr||||S|jr |jjnd}t|t"jt&frMt)|jst-|j} n|j} |j||| St|t0s\|jr|j||S|j||jg}||}|S||||||S)Nrr)rrrr)rrrrrrgrrr^dtypesnextrnot_nonerr%rrrndarrayr)r _selectionr_constructor_slicedr-r_wrap_applied_output_series) rLrrrrrrfirst_not_none key_indexris rMrz%DataFrameGroupBy._wrap_applied_outputb s v;;!   7 J _ 7  M6 X**DL*QQF]]4;//FMclF3T::  !X**4<*@@F]]4;//FM  2 2 ''!1)(  37-IDM..T nrz5&9 : :"  t// 'T_-- 8//id/SS SNF33  } x33F)3LLL..v?P.QQ44V<< 33   rO list[Series]r Index | Nonerc |}td i| fd|D}td|D}|s||d|St jd|D}|} |j} | j@d|D} t| dkr!tt| | _|j tkr|}|j|| | } |js|| } | |jd S) Ncg|]}||n SrKrC)rrbackups rMrz@DataFrameGroupBy._wrap_applied_output_series.. s!CCCq !!FCCCrOc3$K|] }|jV dSrKrrs rMrz?DataFrameGroupBy._wrap_applied_output_series.. s$+D+DAG+D+D+D+D+D+DrOTrc6g|]}tj|SrC)rasarrayrvs rMrz@DataFrameGroupBy._wrap_applied_output_series.. s #B#B#BaBJqMM#B#B#BrOch|] }|j SrCrrs rM z?DataFrameGroupBy._wrap_applied_output_series.. s,,,QV,,,rOrSrrrrC)_construct_axes_dictr-r+rrvstackrr5rirriterrurtolistrgrrrr)rLrrrrrrFall_indexed_samestacked_valuesrrrKrrs @rMrz,DataFrameGroupBy._wrap_applied_output_series sx 4466!!&!!CCCCFCCC++D+DV+D+D+DDD ''!%)( #B#B6#B#B#BCC &++-- < ,,V,,,E5zzQ#DKK00  6 ) )+2244N&&~UG&TT} 90088F""48I">>>rOrrrnc |}dfd }||}j||j}|S)Nrmbvaluesr3rHc0jjd|dfiS)NrrS)rr)r rrFrLs rMarr_funcz4DataFrameGroupBy._cython_transform..arr_func s224=2Wc106 rOre)r r3rHr3)r{r~rgrhrf)rLrrnrFrbr res_mgrrs`` ` rMrz"DataFrameGroupBy._cython_transform s!77%C8           ))H%%//gl/KK rOc|t|r|j|g|Rd|i|Sddlm}g}|j}|j|} |j|g|Ri|\} } t| \} } t | d|  | | | | \}}n$#t$r}d}t||d}~wwxYw| j dkr+t|j| |}||n#t"$rYnwxYw| D]c\} } | j dkrt | d| || }t|j| |}||d|j}||ddd}||d }||S) Nrrrriz3transform must return a scalar value for each groupFT)rrLrrSr)r/rrrrsrr _define_pathsrrr _choose_pathr size_wrap_transform_general_framergr StopIterationrreindexr)rLrrrrDrFrappliedrggen fast_path slow_pathrirpathrrmsg concat_indexrs rMrz#DataFrameGroupBy._transform_general sF 6 " " -4-+8>> df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar', ... 'foo', 'bar'], ... 'B' : ['one', 'one', 'two', 'three', ... 'two', 'two'], ... 'C' : [1, 5, 5, 2, 5, 5], ... 'D' : [2.0, 5., 8., 1., 2., 9.]}) >>> grouped = df.groupby('A')[['C', 'D']] >>> grouped.transform(lambda x: (x - x.mean()) / x.std()) C D 0 -1.154701 -0.577350 1 0.577350 0.000000 2 0.577350 1.154701 3 -1.154701 -1.000000 4 0.577350 -0.577350 5 0.577350 1.000000 Broadcast result of the transformation >>> grouped.transform(lambda x: x.max() - x.min()) C D 0 4.0 6.0 1 3.0 8.0 2 4.0 6.0 3 3.0 8.0 4 4.0 6.0 5 3.0 8.0 >>> grouped.transform("mean") C D 0 3.666667 4.0 1 4.000000 5.0 2 3.666667 4.0 3 4.000000 5.0 4 3.666667 4.0 5 4.000000 5.0 The resulting dtype will reflect the return value of the passed ``func``, for example: >>> grouped.transform(lambda x: x.astype(int).max()) C D 0 5 8 1 5 9 2 5 8 3 5 9 4 5 8 5 5 9 c*|j|g|R||d|S)a Call function producing a same-indexed DataFrame on each group. Returns a DataFrame having the same indexes as the original object filled with the transformed values. Parameters ---------- func : 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 ------- DataFrame DataFrame with the same indexes as the original object filled with transformed values. See Also -------- DataFrame.groupby.apply : Apply function ``func`` group-wise and combine the results together. DataFrame.groupby.aggregate : Aggregate using one or more operations. DataFrame.transform : Call ``func`` on self producing a DataFrame 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. 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 -------- >>> df = pd.DataFrame( ... { ... "A": ["foo", "bar", "foo", "bar", "foo", "bar"], ... "B": ["one", "one", "two", "three", "two", "two"], ... "C": [1, 5, 5, 2, 5, 5], ... "D": [2.0, 5.0, 8.0, 1.0, 2.0, 9.0], ... } ... ) >>> grouped = df.groupby("A")[["C", "D"]] >>> grouped.transform(lambda x: (x - x.mean()) / x.std()) C D 0 -1.154701 -0.577350 1 0.577350 0.000000 2 0.577350 1.154701 3 -1.154701 -1.000000 4 0.577350 -0.577350 5 0.577350 1.000000 Broadcast result of the transformation >>> grouped.transform(lambda x: x.max() - x.min()) C D 0 4.0 6.0 1 3.0 8.0 2 4.0 6.0 3 3.0 8.0 4 4.0 6.0 5 3.0 8.0 >>> grouped.transform("mean") C D 0 3.666667 4.0 1 4.000000 5.0 2 3.666667 4.0 3 4.000000 5.0 4 3.666667 4.0 5 4.000000 5.0 The resulting dtype will reflect the return value of the passed ``func``, for example: >>> grouped.transform(lambda x: x.astype(int).max()) C D 0 5 8 1 5 9 2 5 8 3 5 9 4 5 8 5 5 9 rrrs rMrzDataFrameGroupBy.transformV sBdt    &m  GM   rOctttrfd}fd}nfd}fd}||fS)Nc0t|iSrKrrrDrrFs rMrz0DataFrameGroupBy._define_paths.. s!&:geT&:&:D&KF&K&KrOc<|fddS)Nc0t|iSrKrrs rMrzBDataFrameGroupBy._define_paths.... s!*'!T**D;F;;rOrrrr!s rMrz0DataFrameGroupBy._define_paths.. s.ekk;;;;;;!'2''rOc|gRiSrKrCr!s rMrz0DataFrameGroupBy._define_paths.. s!dd5&B4&B&B&B6&B&BrOc<|fddS)Nc|gRiSrKrCrs rMrzBDataFrameGroupBy._define_paths.... s!$$q24222622rOrrrr!s rMrz0DataFrameGroupBy._define_paths.. s.ekk222222'2''rO)rr)rLrrDrFrrs ``` rMrzDataFrameGroupBy._define_paths s dC KKKKKKIIICBBBBBII)##rOrrrrc|}||}|jdkr||fS ||}n#t$rt$r||fcYSwxYwt|tr$|j|js||fSn=t|tr$|j|js||fSn||fS||r|}||fSr) rr Exceptionrr%requalsr-r)rLrrrrrres_fasts rMrzDataFrameGroupBy._choose_path s/i <1  9   y''HH       9     h * * #**5=99 !Sy  ! & ) ) >((77 !Sy  !9  ??3   DSys *AATrc6g}|j}|j|}|D]\}} t| d||| g|Ri|} | } n#t $rYnwxYwt| st| rIt| r:t| r*| r(| | |tdt| jd|||S)a Filter elements from groups that don't satisfy a criterion. Elements from groups are filtered if they do not satisfy the boolean criterion specified by func. Parameters ---------- func : function Criterion to apply to each group. Should return True or False. dropna : bool Drop groups that do not pass the filter. True by default; if False, groups that evaluate False are filled with NaNs. *args : tuple Additional positional arguments to pass to `func`. **kwargs : dict Additional keyword arguments to pass to `func`. Returns ------- DataFrame The filtered subset of the original DataFrame. See Also -------- DataFrame.filter: Filter elements of ungrouped DataFrame. SeriesGroupBy.filter : Filter elements from groups base on criterion. Notes ----- Each subframe is endowed the attribute 'name' in case you need to know which group you are working on. 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 -------- >>> df = pd.DataFrame( ... { ... "A": ["foo", "bar", "foo", "bar", "foo", "bar"], ... "B": [1, 2, 3, 4, 5, 6], ... "C": [2.0, 5.0, 8.0, 1.0, 2.0, 9.0], ... } ... ) >>> grouped = df.groupby("A") >>> grouped.filter(lambda x: x["B"].mean() > 3.0) A B C 1 bar 2 5.0 3 bar 4 1.0 5 bar 6 9.0 rizfilter function returned a z, but expected a scalar bool)rrrrrsqueezeAttributeErrorrrrrrr rvrwrXr ) rLrrrDrFr rgrrirrs rMrzDataFrameGroupBy.filter sPl m((--  KD%   ufd 3 3 3$u.t...v..C kkmm!    s||  # 499 :::#:NN4??4#8#8999 1$s))2D111 !!'6222sA)) A65A6 DataFrameGroupBy | SeriesGroupByct|tr"t|dkrtdt |S)NrSzRCannot subset columns with a tuple with more than one element. Use a list instead.)rrrr r}rW)rLrPrs rMrWzDataFrameGroupBy.__getitem__q sV c5 ! ! c#hhll& ww""3'''rOndimrQc |dkrP||j}t||j|j|j|j||j|j|j|j |j  S|dkrV| |j|}t||j|j|j|j||j|j|j|j |j  Std)a sub-classes to define return a sliced object Parameters ---------- key : string / list of selections ndim : {1, 2} requested ndim of result subset : object, default None subset to act on rTN) levelgrouper exclusions selectionrrrobservedrrSzinvalid ndim for _gotitem) rgrrr2rr4rrrr6rrar)rLrPr0subsets rM_gotitemzDataFrameGroupBy._gotitem| s 199~# j ?Y?{    QYY~#  j ?Y?{    8999rOrmrirpr4cN|j}|j}|r|}|SrK)rsrtget_numeric_data)rLrnrirgrbs rMr{z'DataFrameGroupBy._get_data_to_aggregate s1'h  )&&((C rOrbcD|j||jSrd)rgrhrf)rLrbs rMrlz$DataFrameGroupBy._wrap_agged_manager sx--c-AAArOcfddlm}jj}fdt jD}fd|D}|st g|jj}n|||d}js6tt||_ |}|S)Nrrc3K|]9\}}tjdd|f|jjjV:dS)N)r5r3r4r6)rarrr4r6)ricolnamergrLs rMrz=DataFrameGroupBy._apply_to_column_groupbys.. so   7 A! ?           rOc&g|] }|SrCrC)rsgbrs rMrz>DataFrameGroupBy._apply_to_column_groupbys.. s!---4499---rOrrrS)rr) rrrsrrr%rrrr,rrr)rLrrrsgbsrrrgs`` @rM_apply_to_column_groupbysz*DataFrameGroupBy._apply_to_column_groupbys s555555'+      ( 44    .------ ;r7$-:TUUUFFVG':::F} 9(V55FL0088F rOc4|fdS)a Return DataFrame with counts of unique elements in each position. Parameters ---------- dropna : bool, default True Don't include NaN in the counts. Returns ------- nunique: DataFrame Counts of unique elements in each position. See Also -------- DataFrame.nunique : Count number of distinct elements in specified axis. Examples -------- >>> df = pd.DataFrame( ... { ... "id": ["spam", "egg", "egg", "spam", "ham", "ham"], ... "value1": [1, 5, 5, 2, 5, 5], ... "value2": list("abbaxy"), ... } ... ) >>> df id value1 value2 0 spam 1 a 1 egg 5 b 2 egg 5 b 3 spam 2 a 4 ham 5 x 5 ham 5 y >>> df.groupby("id").nunique() value1 value2 id egg 1 1 ham 1 2 spam 2 1 Check for rows with the same id but conflicting values: >>> df.groupby("id").filter(lambda g: (g.nunique() > 1).any()) id value1 value2 0 spam 1 a 3 spam 2 a 4 ham 5 x 5 ham 5 y c.|SrK)r")rArs rMrz*DataFrameGroupBy.nunique.. s#++f:M:MrO)rD)rLrs `rMr"zDataFrameGroupBy.nunique s$h--.M.M.M.MNNNrOr{c2|d||S)a Return index of first occurrence of maximum in each group. Parameters ---------- skipna : bool, default True Exclude NA values. numeric_only : bool, default False Include only `float`, `int` or `boolean` data. Returns ------- DataFrame Indexes of maxima in each column according to the group. Raises ------ ValueError When there are no valid values for a group. Then can happen if: * There is an unobserved group and ``observed=False``. * All values for a group are NA. * Some values for a group are NA and ``skipna=False``. .. versionchanged:: 3.0.0 Previously if all values for a group are NA or some values for a group are NA and ``skipna=False``, this method would return NA. Now it raises instead. See Also -------- Series.idxmax : Return index of the maximum element. DataFrame.idxmax : Indexes of maxima along the specified axis. Notes ----- This method is the DataFrame version of ``ndarray.argmax``. Examples -------- Consider a dataset containing food consumption in Argentina. >>> df = pd.DataFrame( ... { ... "consumption": [10.51, 103.11, 55.48], ... "co2_emissions": [37.2, 19.66, 1712], ... "food_type": ["meat", "plant", "meat"], ... }, ... index=["Pork", "Wheat Products", "Beef"], ... ) >>> df consumption co2_emissions food_type Pork 10.51 37.20 meat Wheat Products 103.11 19.66 plant Beef 55.48 1712.00 meat By default, it returns the index for the maximum value in each column according to the group. >>> df.groupby("food_type").idxmax() consumption co2_emissions food_type meat Beef Beef plant Wheat Products Wheat Products rrnr{rrLr{rns rMrzDataFrameGroupBy.idxmax L""8,v"VVVrOc2|d||S)a Return index of first occurrence of minimum in each group. Parameters ---------- skipna : bool, default True Exclude NA values. numeric_only : bool, default False Include only `float`, `int` or `boolean` data. Returns ------- DataFrame Indexes of minima in each column according to the group. Raises ------ ValueError When there are no valid values for a group. Then can happen if: * There is an unobserved group and ``observed=False``. * All values for a group are NA. * Some values for a group are NA and ``skipna=False``. .. versionchanged:: 3.0.0 Previously if all values for a group are NA or some values for a group are NA and ``skipna=False``, this method would return NA. Now it raises instead. See Also -------- Series.idxmin : Return index of the minimum element. DataFrame.idxmin : Indexes of minima along the specified axis. Notes ----- This method is the DataFrame version of ``ndarray.argmin``. Examples -------- Consider a dataset containing food consumption in Argentina. >>> df = pd.DataFrame( ... { ... "consumption": [10.51, 103.11, 55.48], ... "co2_emissions": [37.2, 19.66, 1712], ... "food_type": ["meat", "plant", "meat"], ... }, ... index=["Pork", "Wheat Products", "Beef"], ... ) >>> df consumption co2_emissions food_type Pork 10.51 37.20 meat Wheat Products 103.11 19.66 plant Beef 55.48 1712.00 meat By default, it returns the index for the minimum value in each column according to the group. >>> df.groupby("food_type").idxmin() consumption co2_emissions food_type meat Pork Pork plant Wheat Products Wheat Products rrHrrIs rMrzDataFrameGroupBy.idxminR rJrOr7Sequence[Hashable] | Noner(rr)c4||||||S)aN Return a Series or DataFrame containing counts of unique rows. Parameters ---------- subset : list-like, optional Columns to use when counting unique combinations. normalize : bool, default False Return proportions rather than frequencies. sort : bool, default True Stable sort by frequencies when True. When False, non-grouping columns will appear in the order they occur in within groups. .. versionchanged:: 3.0.0 In prior versions, ``sort=False`` would sort the non-grouping columns by label. ascending : bool, default False Sort in ascending order. dropna : bool, default True Don't include counts of rows that contain NA values. Returns ------- Series or DataFrame Series if the groupby ``as_index`` is True, otherwise DataFrame. See Also -------- Series.value_counts: Equivalent method on Series. DataFrame.value_counts: Equivalent method on DataFrame. SeriesGroupBy.value_counts: Equivalent method on SeriesGroupBy. Notes ----- - If the groupby ``as_index`` is True then the returned Series will have a MultiIndex with one level per input column. - If the groupby ``as_index`` is False then the returned DataFrame will have an additional column with the value_counts. The column is labelled 'count' or 'proportion', depending on the ``normalize`` parameter. By default, rows that contain any NA values are omitted from the result. By default, the result will be in descending order so that the first element of each group is the most frequently-occurring row. Examples -------- >>> df = pd.DataFrame( ... { ... "gender": ["male", "male", "female", "male", "female", "male"], ... "education": ["low", "medium", "high", "low", "high", "low"], ... "country": ["US", "FR", "US", "FR", "FR", "FR"], ... } ... ) >>> df gender education country 0 male low US 1 male medium FR 2 female high US 3 male low FR 4 female high FR 5 male low FR >>> df.groupby("gender").value_counts() gender education country female high US 1 FR 1 male low FR 2 US 1 medium FR 1 Name: count, dtype: int64 >>> df.groupby("gender").value_counts(ascending=True) gender education country female high US 1 FR 1 male low US 1 medium FR 1 low FR 2 Name: count, dtype: int64 >>> df.groupby("gender").value_counts(normalize=True) gender education country female high US 0.50 FR 0.50 male low FR 0.50 US 0.25 medium FR 0.25 Name: proportion, dtype: float64 >>> df.groupby("gender", as_index=False).value_counts() gender education country count 0 female high US 1 1 female high FR 1 2 male low FR 2 3 male low US 1 4 male medium FR 1 >>> df.groupby("gender", as_index=False).value_counts(normalize=True) gender education country proportion 0 female high US 0.50 1 female high FR 0.50 2 male low FR 0.50 3 male low US 0.25 4 male medium FR 0.25 )rM)rLr7r(rr)rs rMrQzDataFrameGroupBy.value_counts s!j!!&)T9fMMMrOr r9c $|jdd|i|}|S)a$ Return the elements in the given *positional* indices in each group. This means that we are not indexing according to actual values in the index attribute of the object. We are indexing according to the actual position of the element in the object. If a requested index does not exist for some group, this method will raise. To get similar behavior that ignores indices that don't exist, see :meth:`.DataFrameGroupBy.nth`. Parameters ---------- indices : array-like An array of ints indicating which positions to take. **kwargs For compatibility with :meth:`numpy.take`. Has no effect on the output. Returns ------- DataFrame A DataFrame containing the elements taken from each group. See Also -------- DataFrame.take : Take elements from a Series along an axis. DataFrame.loc : Select a subset of a DataFrame by labels. DataFrame.iloc : Select a subset of a DataFrame by positions. numpy.take : Take elements from an array along an axis. Examples -------- >>> df = pd.DataFrame( ... [ ... ("falcon", "bird", 389.0), ... ("parrot", "bird", 24.0), ... ("lion", "mammal", 80.5), ... ("monkey", "mammal", np.nan), ... ("rabbit", "mammal", 15.0), ... ], ... columns=["name", "class", "max_speed"], ... index=[4, 3, 2, 1, 0], ... ) >>> df name class max_speed 4 falcon bird 389.0 3 parrot bird 24.0 2 lion mammal 80.5 1 monkey mammal NaN 0 rabbit mammal 15.0 >>> gb = df.groupby([1, 1, 2, 2, 2]) Take elements at rows 0 and 1. Note how the indices selected in the result do not correspond to our input indices 0 and 1. That's because we are selecting the 0th and 1st rows, not rows whose indices equal 0 and 1. >>> gb.take([0, 1]) name class max_speed 1 4 falcon bird 389.0 3 parrot bird 24.0 2 2 lion mammal 80.5 1 monkey mammal NaN The order of the specified indices influences the order in the result. Here, the order is swapped from the previous example. >>> gb.take([1, 0]) name class max_speed 1 3 parrot bird 24.0 4 falcon bird 389.0 2 1 monkey mammal NaN 2 lion mammal 80.5 We may take elements using negative integers for positive indices, starting from the end of the object, just like with Python lists. >>> gb.take([-1, -2]) name class max_speed 1 3 parrot bird 24.0 4 falcon bird 389.0 2 0 rabbit mammal 15.0 1 monkey mammal NaN rSr rwrxrzs rMrSzDataFrameGroupBy.take s'x$#FFGFvFF rOc ,d}|j d|||d|S)a Return unbiased skew within groups. Normalized by N-1. Parameters ---------- skipna : bool, default True Exclude NA/null values when computing the result. numeric_only : bool, default False Include only float, int, boolean columns. **kwargs Additional keyword arguments to be passed to the function. Returns ------- DataFrame Unbiased skew within groups. See Also -------- DataFrame.skew : Return unbiased skew over requested axis. Examples -------- >>> arrays = [ ... ["falcon", "parrot", "cockatoo", "kiwi", "lion", "monkey", "rabbit"], ... ["bird", "bird", "bird", "bird", "mammal", "mammal", "mammal"], ... ] >>> index = pd.MultiIndex.from_arrays(arrays, names=("name", "class")) >>> df = pd.DataFrame( ... {"max_speed": [389.0, 24.0, 70.0, np.nan, 80.5, 21.5, 15.0]}, ... index=index, ... ) >>> df max_speed name class falcon bird 389.0 parrot bird 24.0 cockatoo bird 70.0 kiwi bird NaN lion mammal 80.5 monkey mammal 21.5 rabbit mammal 15.0 >>> gb = df.groupby(["class"]) >>> gb.skew() max_speed class bird 1.628296 mammal 1.669046 >>> gb.skew(skipna=False) max_speed class bird NaN mammal 1.669046 c0td|j)Nz"'skew' is not supported for dtype=rrs rMrz"DataFrameGroupBy.skew..alt rrOr}r~rrrs rMr}zDataFrameGroupBy.skewr sJB N N N (t'  F  IO   rOc &|j dd||d|S)a Return unbiased kurtosis within groups. Parameters ---------- skipna : bool, default True Exclude NA/null values when computing the result. numeric_only : bool, default False Include only float, int, boolean columns. **kwargs Additional keyword arguments to be passed to the function. Returns ------- DataFrame Unbiased kurtosis within groups. See Also -------- DataFrame.kurt : Return unbiased kurtosis over requested axis. Examples -------- >>> arrays = [ ... [ ... "falcon", ... "parrot", ... "cockatoo", ... "kiwi", ... "eagle", ... "lion", ... "monkey", ... "rabbit", ... "dog", ... "wolf", ... ], ... [ ... "bird", ... "bird", ... "bird", ... "bird", ... "bird", ... "mammal", ... "mammal", ... "mammal", ... "mammal", ... "mammal", ... ], ... ] >>> index = pd.MultiIndex.from_arrays(arrays, names=("name", "class")) >>> df = pd.DataFrame( ... { ... "max_speed": [ ... 389.0, ... 24.0, ... 70.0, ... np.nan, ... 350.0, ... 80.5, ... 21.5, ... 15.0, ... 40.0, ... 50.0, ... ] ... }, ... index=index, ... ) >>> df max_speed name class falcon bird 389.0 parrot bird 24.0 cockatoo bird 70.0 kiwi bird NaN eagle bird 350.0 lion mammal 80.5 monkey mammal 21.5 rabbit mammal 15.0 dog mammal 40.0 wolf mammal 50.0 >>> gb = df.groupby(["class"]) >>> gb.kurt() max_speed class bird -5.493277 mammal 0.204125 >>> gb.kurt(skipna=False) max_speed class bird NaN mammal 0.204125 rNr~rrrs rMrzDataFrameGroupBy.kurt s8J(t'  V,  JP   rOr(c$t|}|S)ao Make plots of groups from a DataFrame. Uses the backend specified by the option ``plotting.backend``. By default, matplotlib is used. Returns ------- GroupByPlot A plotting object that can be used to create plots for each group. See Also -------- DataFrame.plot : Make plots of DataFrame. Examples -------- >>> df = pd.DataFrame( ... {"A": [1, 2, 3, 4], "B": [5, 6, 7, 8]}, index=["a", "a", "b", "b"] ... ) >>> g = df.groupby(level=0) >>> g.plot() # doctest: +SKIP rrs rMrzDataFrameGroupBy.plot%s2T"" rOrrSr/str | Callable[[np.ndarray, np.ndarray], float]rc8|d|||}|S)a Compute pairwise correlation of columns, excluding NA/null values. Parameters ---------- method : {'pearson', 'kendall', 'spearman'} or callable Method of correlation: * pearson : standard correlation coefficient * kendall : Kendall Tau correlation coefficient * spearman : Spearman rank correlation * callable: callable with input two 1d ndarrays and returning a float. Note that the returned matrix from corr will have 1 along the diagonals and will be symmetric regardless of the callable's behavior. min_periods : int, optional Minimum number of observations required per pair of columns to have a valid result. Currently only available for Pearson and Spearman correlation. numeric_only : bool, default False Include only `float`, `int` or `boolean` data. .. versionchanged:: 2.0.0 The default value of ``numeric_only`` is now ``False``. Returns ------- DataFrame Correlation matrix. See Also -------- DataFrame.corrwith : Compute pairwise correlation with another DataFrame or Series. Series.corr : Compute the correlation between two Series. Notes ----- Pearson, Kendall and Spearman correlation are currently computed using pairwise complete observations. * `Pearson correlation coefficient `_ * `Kendall rank correlation coefficient `_ * `Spearman's rank correlation coefficient `_ Examples -------- >>> df = pd.DataFrame( ... { ... "age": [2, 3, 4, 6, 6, 1, 2, 1], ... "weight": [2.1, 3.2, 4.1, 6.5, 3.3, 2.1, 4.1, 1.9], ... "pet": ["dog", "cat", "dog", "cat", "dog", "cat", "dog", "cat"], ... } ... ) >>> df age weight pet 0 2 2.1 dog 1 3 3.2 cat 2 4 4.1 dog 3 6 6.5 cat 4 6 3.3 dog 5 1 2.1 cat 6 2 4.1 dog 7 1 1.9 cat >>> df.groupby("pet").corr() age weight pet cat age 1.000000 0.989321 weight 0.989321 1.000000 dog age 1.000000 0.184177 weight 0.184177 1.000000 r)rrrnrx)rLrrrnrs rMrzDataFrameGroupBy.corrAs/\## 6{$   rOrrc8|d|||}|S)a Compute pairwise covariance of columns, excluding NA/null values. Compute the pairwise covariance among the series of a DataFrame. The returned data frame is the `covariance matrix `__ of the columns of the DataFrame. Both NA and null values are automatically excluded from the calculation. (See the note below about bias from missing values.) A threshold can be set for the minimum number of observations for each value created. Comparisons with observations below this threshold will be returned as ``NaN``. This method is generally used for the analysis of time series data to understand the relationship between different measures across time. Parameters ---------- min_periods : int, optional Minimum number of observations required per pair of columns to have a valid result. ddof : int, default 1 Delta degrees of freedom. The divisor used in calculations is ``N - ddof``, where ``N`` represents the number of elements. This argument is applicable only when no ``nan`` is in the dataframe. numeric_only : bool, default False Include only `float`, `int` or `boolean` data. .. versionchanged:: 2.0.0 The default value of ``numeric_only`` is now ``False``. Returns ------- DataFrame The covariance matrix of the series of the DataFrame. See Also -------- Series.cov : Compute covariance with another Series. core.window.ewm.ExponentialMovingWindow.cov : Exponential weighted sample covariance. core.window.expanding.Expanding.cov : Expanding sample covariance. core.window.rolling.Rolling.cov : Rolling sample covariance. Notes ----- Returns the covariance matrix of the DataFrame's time series. The covariance is normalized by N-ddof. For DataFrames that have Series that are missing data (assuming that data is `missing at random `__) the returned covariance matrix will be an unbiased estimate of the variance and covariance between the member Series. However, for many applications this estimate may not be acceptable because the estimate covariance matrix is not guaranteed to be positive semi-definite. This could lead to estimate correlations having absolute values which are greater than one, and/or a non-invertible covariance matrix. See `Estimation of covariance matrices `__ for more details. Examples -------- >>> df = pd.DataFrame( ... { ... "age": [2, 3, 4, 6, 6, 1, 2, 1], ... "weight": [2.1, 3.2, 4.1, 6.5, 3.3, 2.1, 4.1, 1.9], ... "pet": ["dog", "cat", "dog", "cat", "dog", "cat", "dog", "cat"], ... } ... ) >>> df age weight pet 0 2 2.1 dog 1 3 3.2 cat 2 4 4.1 dog 3 6 6.5 cat 4 6 3.3 dog 5 1 2.1 cat 6 2 4.1 dog 7 1 1.9 cat >>> df.groupby("pet").cov() age weight pet cat age 5.583333 4.975000 weight 4.975000 4.529167 dog age 3.666667 0.333333 weight 0.333333 0.893333 r)rrrnrx)rLrrrnrs rMrzDataFrameGroupBy.covs/H## {L$   rOrrAIndexLabel | Nonerrrrrrsharexshareyrrlayouttuple[int, int] | Noner/rrrc B|j d||||||||| | | | | ||d|}|S)a Make a histogram of the DataFrame's columns. A `histogram`_ is a representation of the distribution of data. This function calls :meth:`matplotlib.pyplot.hist`, on each series in the DataFrame, resulting in one histogram per column. .. _histogram: https://en.wikipedia.org/wiki/Histogram Parameters ---------- column : str or sequence, optional If passed, will be used to limit data to a subset of columns. by : object, optional If passed, then used to form histograms for separate groups. grid : bool, default True Whether to show axis grid lines. xlabelsize : int, default None If specified changes the x-axis label size. xrot : float, default None Rotation of x axis labels. For example, a value of 90 displays the x labels rotated 90 degrees clockwise. ylabelsize : int, default None If specified changes the y-axis label size. yrot : float, default None Rotation of y axis labels. For example, a value of 90 displays the y labels rotated 90 degrees clockwise. ax : Matplotlib axes object, default None The axes to plot the histogram on. sharex : bool, default True if ax is None else False In case subplots=True, share x axis and set some x axis labels to invisible; defaults to True if ax is None otherwise False if an ax is passed in. Note that passing in both an ax and sharex=True will alter all x axis labels for all subplots in a figure. sharey : bool, default False In case subplots=True, share y axis and set some y axis labels to invisible. figsize : tuple, optional The size in inches of the figure to create. Uses the value in `matplotlib.rcParams` by default. layout : tuple, optional Tuple of (rows, columns) for the layout of the histograms. bins : int or sequence, default 10 Number of histogram bins to be used. If an integer is given, bins + 1 bin edges are calculated and returned. If bins is a sequence, gives bin edges, including left edge of first bin and right edge of last bin. In this case, bins is returned unmodified. backend : str, default None Backend to use instead of the backend specified in the option ``plotting.backend``. For instance, 'matplotlib'. Alternatively, to specify the ``plotting.backend`` for the whole session, set ``pd.options.plotting.backend``. legend : bool, default False Whether to show the legend. **kwargs All other plotting keyword arguments to be passed to :meth:`matplotlib.pyplot.hist`. Returns ------- matplotlib.Axes or numpy.ndarray A ``matplotlib.Axes`` object or an array of ``Axes`` objects, depending on the layout and grouping. See Also -------- matplotlib.pyplot.hist : Plot a histogram using matplotlib. Examples -------- This example draws a histogram based on the length and width of some animals, displayed in three bins .. plot:: :context: close-figs >>> data = { ... "length": [1.5, 0.5, 1.2, 0.9, 3], ... "width": [0.7, 0.2, 0.15, 0.2, 1.1], ... } >>> index = ["pig", "rabbit", "duck", "chicken", "horse"] >>> df = pd.DataFrame(data, index=index) >>> hist = df.groupby("length").hist(bins=3) r)rArrrrrrrrWrXrrYr/rrrrx)rLrArrrrrrrrWrXrrYr/rrrFrs rMrzDataFrameGroupBy.histsdV$#  !!!  "#  & rOrdropr5ctjdtt|d||||}|S)aO Compute pairwise correlation. .. deprecated:: 3.0.0 Pairwise correlation is computed between rows or columns of DataFrame with rows or columns of Series or DataFrame. DataFrames are first aligned along both axes before computing the correlations. Parameters ---------- other : DataFrame, Series Object with which to compute correlations. drop : bool, default False Drop missing indices from result. method : {'pearson', 'kendall', 'spearman'} or callable Method of correlation: * pearson : standard correlation coefficient * kendall : Kendall Tau correlation coefficient * spearman : Spearman rank correlation * callable: callable with input two 1d ndarrays and returning a float. numeric_only : bool, default False Include only `float`, `int` or `boolean` data. .. versionchanged:: 2.0.0 The default value of ``numeric_only`` is now ``False``. Returns ------- Series Pairwise correlations. See Also -------- DataFrame.corr : Compute pairwise correlation of columns. Examples -------- >>> df1 = pd.DataFrame( ... { ... "Day": [1, 1, 1, 2, 2, 2, 3, 3, 3], ... "Data": [6, 6, 8, 5, 4, 2, 7, 3, 9], ... } ... ) >>> df2 = pd.DataFrame( ... { ... "Day": [1, 1, 1, 2, 2, 2, 3, 3, 3], ... "Data": [5, 3, 8, 3, 1, 1, 2, 3, 6], ... } ... ) >>> df1.groupby("Day").corrwith(df2) Data Day Day 1 0.917663 NaN 2 0.755929 NaN 3 0.576557 NaN z'DataFrameGroupBy.corrwith is deprecated) stacklevelcorrwith)rr\rrn)warningswarnrrry)rLrr\rrnrs rMr_zDataFrameGroupBy.corrwith}s_J  5 '))    ## % $   rOrKrr)rr%rrrrorro) rrrrorrrrorHrr)rrrnrorHr%)rrrrrr%r)rrorHr%)rHr.)r0rQ)rnrorirprHr4)rbr4rHr%r)r{rornrorHr%)NFTFT) r7rLr(rorror)rorrorHr)r r9rHr%r)rrSF)rrSrrQrnrorHr%)NrSF)rrrrrnrorHr%)NNTNNNNNFFNNrNF)rArVrrorrrrrrrrrWrorXrorrrYrZr/rrrprro)FrF) rrr\rorr5rnrorHr%)&rXrYrZrrrrrrrrr)_DataFrameGroupBy__examples_dataframe_docrrrrrWr8r{rlrDr"rrr0boxplotrQrSr}rrrrrrr_rrs@rMrr<sxTxxxxxt C111.*"'" IIIIIV*?*?*?*?^#.0<0<0rrr-ris_rrrrrcrr% _align_frame)rgrrr res_frames rMrrs(#v 9== # # us5='9'99PTUUUI % I #kIOO(( S%5%5q$9:: k)I )Y///// C # #CIMM%+,F,F&&q)) rO)rgr%rr%rrrHr%)gr[ __future__r collectionsrcollections.abcrr] functoolsrtextwraprtypingrr r r r r r`numpyr pandas._libsrpandas._libs.hashtabler pandas.errorsrrpandas.util._decoratorsrpandas.util._exceptionsrpandas.core.dtypes.commonrrrrrrrpandas.core.dtypes.dtypesrrpandas.core.dtypes.inferencerpandas.core.dtypes.missingrr pandas.corer pandas.core.applyr!r"r#r$pandas.core.commoncorecommonrpandas.core.framer%pandas.core.groupbyr&pandas.core.groupby.groupbyr'r(pandas.core.indexes.apir)r*r+r,pandas.core.seriesr-pandas.core.sortingr.pandas.core.util.numba_r/pandas.plottingr0r1r2pandas._typingr3r4r5r6r7r8r9r>r:pandas.core.genericr;rr<r\r= dataclassr@rarrrCrOrMrsG#"""""$$$$$$!!!!!!------/.....444444544444 #""""" ! ''''''$$$$$$ &%%%%%//////333333111111, #"""""++++++Xc3h// ////w~&&  H J/J/J/J/J/J/J/J/Z    |||||GFO||! |~;    QQQQQwy)QQ! Qh<rO