+ Ŝi a0t$Rt^RIHt^RIHt^RIHt^RIt^RI H t ^RI H t ^RI HtHtHtHtHtHt^RIt^RIt^RIHt^R IHt^R IHtHt^R IHt^R I H!t!^R I"H#t#H$t$H%t%H&t&H't'H(t(H)t)^RI*H+t+H,t,^RI-H.t.^RI/H0t0H1t1^RI2H3t3^RI4H5t5H6t6H7t7H8t8^RI9H:uH;t<^RI=H>t>^RI?H@t@^RIAHBtBHCtC^RIDHEtEHFtFHGtGHHtH^RIIHJtJ^RIKHLtL^RIMHNtN^RIOHPtP]'d'^RIHQtQHRtR^RISHTtTHUtUHVtVHWtWHXtXHYtYHZtZ^RI[H\t\^RI]H^t^]_]R]3,,t`R ]aR!&]!R"4tb]!R#4]P!R$R%444td]!R&4!R'R(]B]J,44te]!R&4!R)R*]B]>,44tfR+R,ltgR#)-z 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 ScalarResultpandasc]tRt^mt$RtR]R&R]R&RtR]R&]P!] R7t R ]R &R R lt R Rlt Rt R#)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 r0columnr;aggfuncztuple[Any, ...]args)default_factoryzdict[str, Any]kwargsc ,V^8dQhRRRRRRRRRR /#) r@r0rAzCallable[..., Any] | strrBrrDreturnNone)formats"d/Users/mibo/.openclaw/workspace/.venv-ak/lib/python3.14/site-packages/pandas/core/groupby/generic.py __annotate__NamedAgg.__annotate__s<   *      c 6WnW nW0nW@nR#N)r@rArBrD)selfr@rArBrDs&&&*,rK__init__NamedAgg.__init__s    rNc V^8dQhRRRR/#)rFkeyintrGrrI)rJs"rKrLrMs / /s /s /rNc V^8Xd VP#V^8Xd VP#V^8Xd VP#V^8Xd VP#\ R4h)z/Provide backward-compatible tuple-style access.zindex out of range)r@rArBrD IndexError)rQrUs&&rK __getitem__NamedAgg.__getitem__sR !8;;  AX<<  AX99  AX;; -..rN)rArBr@rDNrI)__name__ __module__ __qualname____firstlineno____doc____annotations__rB dataclassesfielddictrDrRrY__static_attributes__rIrNrKr?r?msD,\  D/(..tDFND  / /rNr?zpandas.api.typingca]tRt^tRRltRRRR/RRlltR V3R lltR@R RR R/R llt]tRt RRlt RARRllt ] !R4t R RR R/RltRBRRlltRRltRCRRlltRCRRlltRDRV3RllltRERR lltR!R"ltRFR#R$lltRFR%R&llt]R'R(l4tRGR)R*lltRGR+R,lltRCR-R.lltRCR/R0lltRHR1R2lltRIR3R4llt]R5R6l4t ]R7R8l4t!RJR9R:llt"]R;R<l4t#R=R>lt$R?t%V;t&#)K SeriesGroupByc V^8dQhRRRR/#)rFmgrr6rGr,rI)rJs"rKrLSeriesGroupBy.__annotate__sw6rNc VPPWPR7pVPPVnV#axes)obj_constructor_from_mgrrmname_name)rQrhouts&& rK_wrap_agged_manager!SeriesGroupBy._wrap_agged_managers1hh,,Sxx,@HHMM  rN numeric_onlyFrpNc$V^8dQhRRRRRR/#)rFruboolrp str | NonerGr7rI)rJs"rKrLris$  # 3=   rNc  VPpVPpV'dF\VP4'g+Rp\ RV R\ V4P RV R24hV#)ruz Cannot use z =True with .z and non-numeric dtypes.)_obj_with_exclusions_mgrrdtype TypeErrortyper[)rQrurpsersinglekwd_names&$$ rK_get_data_to_aggregate$SeriesGroupBy._get_data_to_aggregatesk''  0 ; ;%HhZ{:&&'q.FH  rNcV^8dQhRR/#rFrGr,rI)rJs"rKrLrisg4g4fg4rNc ,<\SV`!V.VO5/VB#)a 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)rQfuncrBrD __class__s&&*,rKrSeriesGroupBy.applysNw}T3D3F33rNengine engine_kwargsc  FVRJpRpV'd\V4wrq/p\V\4'd3\V4'd VeW%R&VeW5R&\ W4!V/VB#\V\ P 4'db\V4pW%R&W5R&VP!V.VO5/VBpV'd VfQhWxn VP'gVP4pV#\V4'dVP!V.VO5RV/VB#VP^8XdmVPp VPVP P#.VP P$VP&P(V P*R74#VP,!V.VO5/VB#)aL 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 Nrrrpindexr})r# isinstancestrr.getattrrIterabler!_aggregate_multiple_funcscolumnsas_index reset_index_aggregate_with_numbangroupsr{_wrap_aggregated_outputrn _constructorrp_grouper result_indexr}_python_agg_general) rQrrrrBrD relabelingrretrns &&$$*, rK aggregateSeriesGroupBy.aggregate:s~T\  08MGF dC v&&6+= $*x (*7'4&77 7 cll + +(-D%8 &3? #00GGGC***% ===oo'Jv&&11/<@F||q //33HH))!XX]]"mm88!ii *++DB4B6B BrNc aaaVVV3RlpVPpVPPWT4pVPWePR7pVP V4#)c<S!V.SO5/SB#rPrIxrBrrDs&rK3SeriesGroupBy._python_agg_general..d1.t.v.rN)rp)r{r agg_seriesrrpr)rQrrBrDfrnresultress&fjl rKr!SeriesGroupBy._python_agg_generalsO .''))#1vHH5++C00rNcV^8dQhRR/#rFrGr$rI)rJs"rKrLrisrNc \V\4'd \R4h\;QJdRV4F 'gK RM RM !RV44'd RV4pMRV4p\ WARR7p/p\ P !VRR4;_uu_4\V4F7wpwrx\P!WvR7p VP!V.VO5/VBWY&K9 R R R 4\;QJd*R VP44F 'gK RM RM!R VP444'd;^R I H p T !VP4^VU u.uFqPNK up R 7p V #VP4U U u/uFwrV P V bK p p p VP"P%V R R 7p\'RV44VnV# +'giEL;iuup iuup p i)znested renamer is not supportedc3N"TFp\V\\34xK R#5irPrtuplelist.0rs& rK :SeriesGroupBy._aggregate_multiple_funcs..s9Sz!eT]++Ss#%TFc3d"TF&p\V\\34'gW3MTxK( R#5irPrrs& rKrrs'RcAt}!=!=A61Dcs.0c3b"TF%p\P!V4;'gTxK' R#5irP)comget_callable_name)rrs& rKrrs&Bcs,,Q/4414cs!/ /)strictr)labelpositionNc3B"TFp\V\4xK R#5irP)rr$rs& rKrr sB1AAz!Y''1Asconcat)axiskeysrc38"TFqPxK R#5irP)r)rrUs& rKrrs   dJ 5 5&/s^!\dnn4>#~~dDTDVD &46 3B1AB333B1AB B B % qW/MWc W/MFM>> 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 6VP!V.VO5RVRV/VB#)aL 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 rr _transformrQrrrrBrDs&&$$*,rK transformSeriesGroupBy.transforms9N   & 6C GM  rNc V^8dQhRRRR/#)rFhowrrurwrI)rJs"rKrLris M MS M MrNc 0VPpVPP!RVPV^3/VBpTPYPPPTPR7# \d"p\ T RTP R24ThRp?ii;i)rz is not supported for z dtypeNrrp) r{r_cython_operation_valuesNotImplementedErrorr~r}rrnrrp)rQrrurDrnrerrs&&&, rK_cython_transformSeriesGroupBy._cython_transforms'' V]]44S[[#q4:Fhhnn388LL # Vse#9#))FKLRU U Vs*A)) B4BBc V^8dQhRRRR/#)rFrrrGr,rI)rJs"rKrLri#s!!! !rNc p\V4'dVP!V.VO5RV/VB#\V4'gQh\VP4p.pVP P VP4FJwr\PV RV4V!V .VO5/VBp VPV!WPR74KL V'd#^RI H p V !VRR7p VPV 4p M*VPP\ P"R7p VPP$V nV #)z# Transform with a callable `func`. rrprrT) ignore_indexr})r._transform_with_numbacallablerrnr get_iteratorr{object __setattr__appendrpandas.core.reshape.concatr_set_result_index_orderedrnpfloat64rp)rQrrrrBrDklassrrpgrouprr concatenatedrs&&&&*, rK_transform_general SeriesGroupBy._transform_general#s 6 " "--+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 c(<\VS4!S/SB#rPrrs&rKr&SeriesGroupBy.filter..zs4 0$ A& ArNc<S!V.SO5/SB#rPrIrs&rKrr|sQ 8 8 8rNcV^8dQhRR/#)rFrGrwrI)rJs"rKrL*SeriesGroupBy.filter..__annotate__s " " "rNc><S!V4p\V4;'dT#rP)r)rbwrappers& rKtrue_and_notna,SeriesGroupBy.filter..true_and_notnas A8>> !rNz'the filter must return a boolean resultN) rrrrr{ _get_index ValueErrorr~ _apply_filter) rQrrrBrDrrprindicesrfilteredrs &f&jl @rKfilterSeriesGroupBy.filterFsf dC AG8G " " P$(==#=#=d>W>W#X#XKD!%(&%#X %%g6 I& PEFC O Ps/(B&B 5B  B& B&&C7 CCc V^8dQhRRRR/#)rFrrwrGSeries | DataFramerI)rJs"rKrLrisCCdC.@CrNc 0VPPpVPPpVPPp\ P !WARR7wrVVPP'dV^8pW',pWW,p\W%.V\V43RVR7pV'd-V^8pV(P4'dW',pW,p\VR4p\P!W'(,VR7p \V 4p VPPp VPP!WVPP"R7p VP$'g+VP'V 4p \)\V 44V nV #)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_sentinelsort)labelsshaper+xnullfirst) minlengthr)ridsrrnrr factorizehas_dropped_nar-rrrr bincountrrrrprrr+r) rQrr1rrcodesuniquesmask group_indexrrirs && rKnuniqueSeriesGroupBy.nuniquesIBmm--''hh#--cPUV == ' ' '!8D)CKE%<CL)   !#D{{}}i)/ +w/kk#e*83 ]] ' '%)XX%:%:  &;& }}}008F(V5FL rNcV^8dQhRR/#rrI)rJs"rKrLrisl l l rNc &<\SV`WVR7#)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)rdescribe)rQr>r?r@rs&&&&rKrASeriesGroupBy.describes"Tw#g   rNc ,V^8dQhRRRRRRRRRR/#)rF normalizerwr+ ascendingrrGr(rI)rJs"rKrLriBsCxxxx x  x xrNc a*a+V'dRMRpVfVPWW5R7pWgnV#^RIHp^RIHp VP Pp VPPp .VP POVPPNp \V P\4'g!VeY\P!V4'g=VP!\"P$VVVVR7p WmnWP&n V #V R8gpW,W,rVf \(P*!V RR 7wppR pMcV !\#V R R 7VRR 7p\-RVP4pVP.pVP1VP2RVP4R7pRp\VP\64'd?\-\8V4p\P:!VP<VP>V 34pM\P:!W34pV V,VV,r^\P@!V R,V RR8g4^,,p\PB^V3,p\EV 4'gTpV!V\G^R44V!V\GRR448gp\PBRV3,p\EV 4'gTpRVV&\PH!\P@!\PBVR3,4^,4p\K\PL\PNPQVV4R7p\VP PR\T4'd+\WVP PRP24pM]\(P*!VP PRVP PXVP PZR7^,.pVUu.uF pV!V4NK upV!VV4.,p.VP P\OVNpV'dGVR,R8gpVP_4'dR pM!VV,VUu.uF pVV,NK pppV'dVPaR4p\PH!\PBV\EV 43,4pV'd=WR8H,p \PNPcVV R4V!V4V,p!MV!V4p!VV!,pV'dfVfbV'dV V,V,MV V,p"\P:!V'dTMV)V"34pVV,VR,V,upVR&VEe\Pd!\EV4RR7o*VRRF0pS*\PBRVR,VRR8g3,,o*K2 S*Pg4\EVR,4up#o+\PL!\Ph!V#4S+4\Pj!\Ph!S+4V#4.p$S*Pm4^, VR,.p%V!V$V%R RR7wp&pVe#\Pn!VR8gVV,^4pV'dH\P:!V'dTMV)V$^,34pVV,V$R,V,upV$R&RV*V+3Rllp'VRRU(u.uF p(V'!V(4NK pp(VPqV$R,4\UVVV R R7p)\sVP4'd \uV4pVPPwVV)VR7pVPx'gVP{4pV#uupiuupiuup(i)a Return a Series or DataFrame containing counts of unique rows. Parameters ---------- normalize : bool, default False Return proportions rather than frequencies. sort : bool, default True Sort by frequencies. ascending : bool, default False Sort in ascending order. bins : int or list of ints, optional Rather than count values, group them into half-open bins, a convenience for pd.cut, only works with numeric data. 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. DataFrameGroupBy.value_counts: Equivalent method on DataFrameGroupBy. 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 -------- >>> 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)rDr+rEr)get_join_indexers)cut)rDr+rEbinsT)r+cW,#rPrIlabincs&&rKr,SeriesGroupBy.value_counts..sCHrNF)copy)include_lowestr9) allow_fill fill_valuecHW,PPR,#)) _multiindexr5rMs&&rKrrPsCH$8$8$>$>r$BrN:rVNN)repeats)r+r*floatrwrleft)r+rc V^8dQhRRRR/#)rF lev_codesz np.ndarrayrGrI)rJs"rKrL0SeriesGroupBy.value_counts..__annotate__+s 8 8z 8j 8rNc@<\P!VS,S4#rP)r repeat)r]diffnbins&rK build_codes/SeriesGroupBy.value_counts..build_codes+syy4$77rN)levelsr5namesverify_integrityrrW)> _value_countsrppandas.core.reshape.mergerIpandas.core.reshape.tilerJrr1rnrrfrr}rr iterablerr, value_countsrrr2r categoriestaker5 _na_valuerr lexsortr[rightnonzeror_rslicerarr`addreduceatrr)r_sortrreallastypeatzerossumarangetilecumsumwhererrrrrr),rQrDr+rErKrrprrIrJr1r index_namesrr7rNlevllabcat_sercat_obj lab_intervalsorter idchangesrlchangesrOrrrepr5 level_codesredmacccatncatr[rq_rcr]mirarbs,&&&&&& @@rKrlSeriesGroupBy.value_countsBsaj )|g <''#)(FKM?0mmhh; ++;TXX]]; cii!1 2 2  R[[%6%6 **#### CH)IIOJby9ciS <!++Cd;HC,D&514MG='//:G$$C(( ==C CD cii / /#.LZZ!2!2L4F4F LMFZZ +Fv;F S 3r7c#2h#67:: eeAyL!3xxCU1d^,S%b/0JJeeD(N#3xxCCggbjjsDy!12156biic)BC dmm00* = =3399:E$$MM..,,$(MM$8$8 E6;;Uk[!U;tC~>NN-4==''-- 9?Dxxzz Ye(Te{T):):eU(T **W%Cc3s8m,-Ar N !Q#!fTl!f 3JC DL$*#c(4.CCZZ tS ABF [%)F*;NCr  88CHF3D$Sbz dKO{3B7G$GGHH *S_JD$IIbiiot4bggbiiot6TUD[[]Q&b 2E ' FAs hhsby#c(A6ISC4a$IJ #F T"Xf-= T"X 8 8>C3BZHZ [+ZEH LLb " kE  CII & &s#C&&s"4&@}}}'')F O<)UfIs_&_+_0c V^8dQhRRRR/#)rFr#r8rGr,rI)rJs"rKrLri<s"PPP  PrNc .VP!RRV/VBpV#)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 r#rn _op_via_applyrQr#rDrs&&, rKrnSeriesGroupBy.take<s"^##FGFvF rNc$V^8dQhRRRRRR/#rFskipnarwrurGr,rI)rJs"rKrLris-C C C C  C rNc 2VP!RRRRVRV/VB#)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 altNrruskew_cython_agg_generalrQrrurDs&&&,rKrSeriesGroupBy.skews8B''  %+ :F JP  rNc$V^8dQhRRRRRR/#rrI)rJs"rKrLris-L L L L  L rNc 8RpVP!RRVRVRV/VB#)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 c2\RVP 24h)z"'kurt' is not supported for dtype=r~r}rns&rKrSeriesGroupBy.kurt..alt@ LM MrNrrrukurtrrQrrurDrs&&&, rKrSeriesGroupBy.kurts>J N ''  $* 9E IO  rNcV^8dQhRR/#rFrGr'rI)rJs"rKrLri"skrNc \V4pV#)a 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'rQrs& rKplotSeriesGroupBy.plot!s.T" rNc$V^8dQhRRRRRR/#rFnrVkeepzLiteral['first', 'last', 'all']rGr,rI)rJs"rKrLri;$>>> ?> >rNc z\\PWR7pVPpVP W4RR7pV#)aa 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,nlargestr{_python_apply_generalrQrrrrrs&&& rKrSeriesGroupBy.nlargest;s<r FOOq 4((++Ad+K rNc$V^8dQhRRRRRR/#rrI)rJs"rKrLri{rrNc z\\PWR7pVPpVP W4RR7pV#)aR 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, nsmallestr{rrs&&& rKrSeriesGroupBy.nsmallest{s>r F$$ 5((++Ad+K rNc V^8dQhRRRR/#rFrrwrGr,rI)rJs"rKrLri;<;>> 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_idxminrQrs&&rKrSeriesGroupBy.idxminv""8F";;rNc V^8dQhRRRR/#rrI)rJs"rKrLrirrNc (VPRVR7#)aI 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&&rKrSeriesGroupBy.idxmaxrrNc(V^8dQhRRRRRRRR/#)rFotherr,rr4 min_periods int | NonerGrI)rJs"rKrLri5s2%%%"% %  %rNc .VPRWVR7pV#)ai 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)rrrr)rQrrrrs&&&& rKrSeriesGroupBy.corr5s(D## %K$  rNc(V^8dQhRRRRRRRR/#)rFrr,rrddofrGrI)rJs"rKrLri\s,"""*4"CM" "rNc .VPRWVR7pV#)aO 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)rrrr)rQrrrrs&&&& rKrSeriesGroupBy.cov\s'>## d$  rNcV^8dQhRR/#rrI)rJs"rKrLriCCCrNc &VPR4#)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 cVP#rP)is_monotonic_increasingrs&rKr7SeriesGroupBy.is_monotonic_increasing.. c&A&ArNrrQs&rKr%SeriesGroupBy.is_monotonic_increasing,zzABBrNcV^8dQhRR/#rrI)rJs"rKrLrirrNc &VPR4#)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 cVP#rP)is_monotonic_decreasingrs&rKr7SeriesGroupBy.is_monotonic_decreasing..rrNrrs&rKr%SeriesGroupBy.is_monotonic_decreasingrrNc<V^8dQhRRRRRRRRRRR R R R R RRR/ #)rFgridrw xlabelsizerxrot float | None ylabelsizeyrotfigsizetuple[float, float] | NonerKint | Sequence[int]backendrxlegendrI)rJs"rKrLrisqLL L  L  LLL,L"LLLrNc  VVP!R RVRVRVRVRVRVRVRVR V R V R V / V Bp V #) a 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 byaxrrrrrrrKrrhistr)rQrrrrrrrrrKrrrDrs&&&&&&&&&&&&, rKrSeriesGroupBy.histsz##     "    "        rNcV^8dQhRR/#rrI)rJs"rKrLris 1 1v 1rNc &VPR4#)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. cVP#rPrrs&rKr%SeriesGroupBy.dtype.. sciirNrrs&rKr}SeriesGroupBy.dtypeszz/00rNcV^8dQhRR/#rrI)rJs"rKrLri s---rNc (VPR4pV#)a4 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 uniquerrs& rKrSeriesGroupBy.unique sX##H- rNrIrPFFFT)NNN)FTFNTTF)r/)pearsonN)NrV) NNTNNNNN NF)'r[r\r]r^rsrrraggrrrr#_SeriesGroupBy__examples_series_docrrrr%r:rArlrnrrpropertyrrrrrrrrrrr}rrd __classcell__rs@rKrfrfsT &+ @D g4g4RsCsCTsCj C1BFCP#% 'RI DI I V M!FGRCJl l \xtPdC JL \2>@>@;R R lltR R lt R?RRllt Rt ] !R4t RRRR/RltRtRRltR@RRlltRV3RlltR=RRlltRR RR/RRlltR R!ltR"R#ltR@R$R%lltRAR&R'lltRAR(R)llt]tRBR*R+lltR,R-ltRAR.R/lltRAR0R1llt] R2R3l4t!RCR4R5llt"RDR6R7llt#RER8R9llt$RFR:R;llt%R 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)rBrDNNNNzNo objects to concatenaterI)r"r!r.r rrrrrr r$ilocrrrnkeysr_aggregate_framer{rQr!rrr+rr) rQrrrrBrDrrorderoprgbars &&$$*, rKrDataFrameGroupBy.aggregate>sV,6!8$?+v&&11/<@F}}""Q&//FtFvFF..tEdEfE#4bDN WWYF ")V4F%)%>%>%F%F%K%K%MFN}}}008F(V5FL +" 92#c(B"2248F 9sH H>"H99H>c aaaVVV3RlpVP^8XdVPW@PRR7#VPp\ VP 4'gVPW@P4#/p\ VP44F'wpwrVPPW4p WV&K) VPPV4p VP PRR7V nVPV 4#)c<S!V.SO5/SB#rPrIrs&rKr6DataFrameGroupBy._python_agg_general..; rrNT)is_aggF)deep)rr _selected_objr{rrrrrrrnrrQr) rQrrBrDrrnrrrprrrs &fjl rKr$DataFrameGroupBy._python_agg_general: s . <<1 --a1C1CD-Q Q''3;;--a1C1CD D') )#))+ 6 C$]]--c5F 3K!7hh##F+kk&&E&2 ++C00rNcV^8dQhRR/#rrI)rJs"rKrLDataFrameGroupBy.__annotate__Q srNc hVPP^8wd \R4hVPp/pVPP V4FwrgV!V.VO5/VBpWV&K VPP p VP PWTPV R7p V Pp V #)rVzNumber of keys must be 1rr) rr!AssertionErrorr{rrrnrrT) rQrrBrDrnrrpgrp_dffresrrrs &&*, rKr"!DataFrameGroupBy._aggregate_frameQ s ==  ! # !;< <''79 MM66s;LD000D4L<}}11 hh##F++|#Tee rNFc(V^8dQhRRRRRRRR/#)rFrr$rrrrwrrI)rJs"rKrLr/b s8IIII I  IrNc \V4^8XdV'dVPpM+VP'gRpMVPPpVP P WQPR7pVPVP4pV#\\P!V!R4pVfDVP P VPR7pVPVP4pV#\V\4'dVPVVVR7#VP 'dVPPMRp\V\"P$\&34'd[\)VP*4'g\-VP*4p M VP*p VP P/W(V R7#\V\04'giVP 'dVP P/W(R7#VP P W P*.R7pVP3V4pV#VP5VVVVV4#)Nr1)rrrr)rrrrrrnrrrydtypesnextrnot_nonerr$rrr ndarrayr(r _selectionr_constructor_slicedr,r_wrap_applied_output_series) rQrrrrrrfirst_not_none key_indexrps &&&&& rKr%DataFrameGroupBy._wrap_applied_outputb s v;!  JJ ___  MM66 XX**LL*QF]]4;;/FMcllF3T:  !XX**4<<*@F]]4;;/FM  2 2''!1)(  37---DMM..T nrzz5&9 : : t//T__- 88//d/S SNF33 }}}xx33F3LL..v?P.Q44V< 33   rNc ,V^8dQhRRRRRRRRRR /#) rFrz list[Series]rrwrBz Index | NonerrGrrI)rJs"rKrLr/ s<*?*?*?*?  *?  *? *?rNc 0VP4p\R/VBpVUu.uF qeTMTNK pp\RV44p V 'gVPVRVR7#\P !VU u.uFp \P !V 4NK up 4p Tp VPP4p V PfDVU u0uFqPkK pp \V4^8Xd\\V44V n V P\8XdV P4p VP P#WV R7pVP$'gVP'V4pVP)VP RR7#uupiuup iuup i)Nc38"TFqPxK R#5irPrrs& rKr?DataFrameGroupBy._wrap_applied_output_series.. s+DVGGVrTrr1rrrI)_construct_axes_dictr,r*rr vstackasarrayrrQrprr;iterr}rtolistrnrrrr)rQrrrArBrrDbackuprall_indexed_samevstacked_valuesrrrfrs&&&&&& rKr@,DataFrameGroupBy._wrap_applied_output_series sd 446!&!>AD$C -sF 4FFc$V^8dQhRRRRRR/#)rFrrrurwrGr$rI)rJs"rKrLr/ s(   rNc aaaSPVSR7pRVVV3RllpVPV4pSPPWfPR7pV#))rurpc V^8dQhRRRR/#)rFbvaluesr2rGrI)rJs"rKrL8DataFrameGroupBy._cython_transform..__annotate__ s  i I rNcD<SPP!RVS^3/SB#)r)rr)rUrrDrQs&rKarr_func4DataFrameGroupBy._cython_transform..arr_func s+==22Wc106 rNrl)rrrnrorm)rQrrurDrhrXres_mgrrsff&l rKr"DataFrameGroupBy._cython_transform sY!77%C8    ))H%//ll/K rNc j\V4'dVP!V.VO5RV/VB#^RIHp.pVPpVP P V4p VP!V.VO5/VBwr\V 4wr\PV RV 4VPWV 4wrT P^8d(\TPY4pTP!T4T F^wrT P^8XdK\PT RT 4X!T 4p\TPY4pTP!T4K` TP$pT!T^RRR7pTP'T^R7pTP)T4# \dpRp\T4ThRp?ii;i \"dLi;i) rrrpz3transform must return a scalar value for each groupNFT)rrgrr)r.rr rr{rr _define_pathsr;rr _choose_pathr!size_wrap_transform_general_framernr StopIterationrreindexr )rQrrrrBrDrappliedrngen fast_path slow_pathrprpathrrmsg concat_indexrs&&&&*, rKr#DataFrameGroupBy._transform_general s 6 " "--+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 6VP!V.VO5RVRV/VB#)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 rrrrs&&$$*,rKrDataFrameGroupBy.transformV s9d   & 6C GM  rNc aaa\S\4'dVVV3RlpVVV3RlpWE3#VVV3RlpVVV3RlpWE3#)c(<\VS4!S/SB#rPrrrBrrDs&rKr0DataFrameGroupBy._define_paths.. sgeT&:D&KF&KrNc6<VPVVV3Rl^R7#)c(<\VS4!S/SB#rPrrs&rKrBDataFrameGroupBy._define_paths.... s'!T*D;F;rNr]rrps&rKrrq sekk;!'2'rNc<S!V.SO5/SB#rPrIrps&rKrrq sd5&B4&B6&BrNc6<VPVVV3Rl^R7#)c<S!V.SO5/SB#rPrIrs&rKrrt s$q24262rNr]rrps&rKrrq sekk2'2'rN)rr)rQrrBrDrfrgs&fjl rKr^DataFrameGroupBy._define_paths sA dC KII## CII##rNc$V^8dQhRRRRRR/#)rFrfrrgrr$rI)rJs"rKrLr/ s!""h"8"I"rNc TpV!V4pVP^8XdWE3#V!V4p\T\4'd0TP P TP 4'gYE3#MH\T\4'd0TPP TP 4'gYE3#MYE3#TP T4'dTpYE3# \dh\dYE3u#i;i)rV) rr2 Exceptionrr$requalsr,r)rQrfrgrrhrres_fasts&&&& rKr_DataFrameGroupBy._choose_path s <<1 9   'H h * *##**5==99y : & ) )>>((77y 89  ??3  Dy-   9  sCC-&C-,C-c V^8dQhRRRR/#rFrrwrGr$rI)rJs"rKrLr/ sR3R34R3IR3rNc :.pVPpVPPV4pVFwr\P V RV4V!V .VO5/VBp V P 4p \V 4'g#\V 4'dQ\V 4'd@\V 4'd-V 'd#VPVPV44KKK\R\V 4P R24h VP!WR4# \ dLi;i)ar 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 rpzfilter function returned a z, but expected a scalar bool)r,rrrrsqueezeAttributeErrorrrrrrr r~rr[r") rQrrrBrDr#rnrerprrs &&&*, rKr%DataFrameGroupBy.filter sl  mm((-KD   ufd 3u.t.v.C kkm s|| #499::#NN4??4#89#&: 1$s)2D2D1EF11%.!!'22"  sD  DDcV^8dQhRR/#)rFrGz DataFrameGroupBy | SeriesGroupByrI)rJs"rKrLr/q s ( ("B (rNc <\V\4'd\V4^8d \R4h\SV`V4#)rVzRCannot subset columns with a tuple with more than one element. Use a list instead.)rrrr!rrY)rQrUrs&&rKrYDataFrameGroupBy.__getitem__q s@ c5 ! !c#hl& w"3''rNcV^8dQhRR/#)rFndimrVrI)rJs"rKrLr/| s.:.:#.:rNc BV^8XdVf VPp\VVPVPVPVP VVP VPVPVPVPR7 #V^8XdVfVPV,p\VVPVPVPVP VVP VPVPVPVPR7 #\R4h)z 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 ) levelgrouper exclusions selectionrr+robservedrzinvalid ndim for _gotitem) rnrrrrrrr+rrrrfr2)rQrUrsubsets&&&&rK_gotitemDataFrameGroupBy._gotitem| s 19~# jj ??YY??{{  QY~#  jj ??YY??{{  899rNrurpc$V^8dQhRRRRRR/#)rFrurwrprxrGr3rI)rJs"rKrLr/ s$#3= rNc fVPpVPpV'dVP4pV#rP)r{r|get_numeric_data)rQrurprnrhs&$$ rKr'DataFrameGroupBy._get_data_to_aggregate s.''hh &&(C rNc V^8dQhRRRR/#)rFrhr3rGr$rI)rJs"rKrLr/ sBB|B BrNc NVPPWPR7#rk)rnrorm)rQrhs&&rKrs$DataFrameGroupBy._wrap_agged_manager sxx--c-AArNcV^8dQhRR/#rrI)rJs"rKrLr/ srNc aa^RIHpSPoSPpVV3Rl\ SP44pVUu.uF qQ!V4NK ppV'g$\ .VSP PR7pM V!Wc^R7pSP'g+\\V44Vn SPV4pV#uupi)r9rc 3<"TFHwr\SPRV3,VSPSPSPR7xKJ R#5i)r)rrrrN)rfr rrr)ricolnamernrQs& rKr=DataFrameGroupBy._apply_to_column_groupbys.. sO  5  A! ??   5sAArr)rr) r rr{rrr$rrrr+rrr) rQrrrsgbssgbrrrns f& @rK_apply_to_column_groupbys*DataFrameGroupBy._apply_to_column_groupbys s5''++  ( 4  )--49-r7$--:T:TUFG:F}}}(V5FL008F .sC c V^8dQhRRRR/#rrI)rJs"rKrLr/ s4O4Od4Oi4OrNc .aVPV3Rl4#)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&<VPS4#rP)r:)rrs&rKr*DataFrameGroupBy.nunique.. s#++f:MrN)r)rQrs&frKr:DataFrameGroupBy.nunique sh--.MNNrNc$V^8dQhRRRRRR/#rFrrwrurGr$rI)rJs"rKrLr/ 2FWFWFWFW  FWrNc (VPRW!R7#)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 rrurrrQrrus&&&rKrDataFrameGroupBy.idxmax L""8,"VVrNc$V^8dQhRRRRRR/#rrI)rJs"rKrLr/R rrNc (VPRW!R7#)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 rrrrs&&&rKrDataFrameGroupBy.idxminR rrNc 0V^8dQhRRRRRRRRRRRR /#) rFrzSequence[Hashable] | NonerDrwr+rErrGrrI)rJs"rKrLr/ sVuNuN)uNuN uN  uN  uN uNrNc (VPWW4V4#)af 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 )rh)rQrrDr+rErs&&&&&&rKrlDataFrameGroupBy.value_counts sj!!&TfMMrNc V^8dQhRRRR/#)rFr#r8rGr$rI)rJs"rKrLr/ s"]]]  ]rNc .VP!RRV/VBpV#)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 r#rrrs&&, rKrnDataFrameGroupBy.take s"x##FGFvF rNc$V^8dQhRRRRRR/#rrI)rJs"rKrLr/r s-H H H H  H rNc 8RpVP!RRVRVRV/VB#)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 c2\RVP 24h)z"'skew' is not supported for dtype=rrs&rKr"DataFrameGroupBy.skew..alt rrNrrrurrrs&&&, rKrDataFrameGroupBy.skewr s>B N ''  $* 9E IO  rNc$V^8dQhRRRRRR/#rrI)rJs"rKrLr/ s-g g g g  g rNc 2VP!RRRRVRV/VB#)aL 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 rNrrurrrs&&&,rKrDataFrameGroupBy.kurt s8J''  %+ :F JP  rNcV^8dQhRR/#rrI)rJs"rKrLr/&skrNc \V4pV#)a 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& rKrDataFrameGroupBy.plot%s2T" rNc(V^8dQhRRRRRRRR/#) rFrz/str | Callable[[np.ndarray, np.ndarray], float]rrVrurwrGr$rI)rJs"rKrLr/As8QQ?QQ Q  QrNc .VPRWVR7pV#)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)rrrur)rQrrrurs&&&& rKrDataFrameGroupBy.corrAs(\## 6$  rNc(V^8dQhRRRRRRRR/#)rFrrrrurwrGr$rI)rJs"rKrLr/s8gggg g  grNc .VPRWVR7pV#)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)rrrur)rQrrrurs&&&& rKrDataFrameGroupBy.covs(H## {L$  rNcLV^8dQhRRRRRRRRR RR RR RR RR RRRRRRRRR/ #)rFr@zIndexLabel | Nonerrwrrrrrrsharexshareyrrlayoutztuple[int, int] | NonerKrrrxrrI)rJs"rKrLr/s~~!~ ~  ~  ~~~~~,~'~"~~ !~rNc! fVP!RRVRVRVRVRVRVRVRVR V R V R V R V R V RVRV/VBpV#)aT 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@rrrrrrrrrrrrKrrrr)rQr@rrrrrrrrrrrrKrrrDrs&&&&&&&&&&&&&&&&, rKrDataFrameGroupBy.histsV##     "    "         ! "# & rNc ,V^8dQhRRRRRRRRRR /#) rFrrdroprwrr4rurGr$rI)rJs"rKrLr/}sCQQ!QQ" Q  Q  QrNc |\P!R\\4R7VP RVVVVR7pV#)a 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)rrrru)warningswarnrrr)rQrrrrurs&&&&& rKrDataFrameGroupBy.corrwith}sJJ  5 ') ## % $  rNrIrPrrrr)NFTFT)rrVF)NrVF)NNTNNNNNFFNNrNF)FrF)(r[r\r]r^rrrr"rr@rrr)_DataFrameGroupBy__examples_dataframe_docrr^r_r%rYrrrsrr:rrr/boxplotrlrnrrrrrrrrrdrrs@rKrr<sxxTxt C1."IV*?X.0rsi#$!-/45 # ! '$ &/31 #+Xc3h// 9/~&  H J/J/J/Z  |GFO|!|~;  Qwy)Q!Qh<rN