ujUdZddlmZddlmZmZmZmZmZm Z ddl Z ddl m Z m Z ddlmZmZmZmZmZmZmZmZmZddlZddlZddlmZmZddlmZddl m!cm"Z#dd l$m%Z%dd l&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1dd l2m3Z4dd l5m6Z6m7Z7m8Z8dd l9m:Z:ddl;mZ>m?Z?ddl@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKddlLmMZMmNZNmOZOddlPmQZQmRZRddlSmTZTddlUmVZVmWZWmXZXmYZYddlZm[Z[ddl\m]Z]ddl^m_Z_m`Z`ddlambcmcZdddlemfZfddlgmhZhddlimjZjmkZkmlZlddlmmnZnddlompZpmqZqddlrmsZsmtZtmuZuddlvmwZwddlxmyZydd lzm{Z{dd!l|m}Z}m~Z~mZer2dd"lmZdd#lmZdd$l&mZmZmZmZmZmZdd%lmZdd&lmZdd'lmZmZmZeGd(d)e_ZeeezeegefzeeegefzeeefzZd*ed+<Gd,d-e_e`e,epZed.eh/ZGd0d1ee,Z d4 d5d2Zd6d3Zy)7a Provide the groupby split-apply-combine paradigm. Define the GroupBy class providing the base-class of operations. The SeriesGroupBy and DataFrameGroupBy sub-class (defined in pandas.core.groupby.generic) expose these user-facing objects to provide specific functionality. ) annotations)CallableHashableIterableIteratorMappingSequenceN)partialwraps) TYPE_CHECKING ConcatenateLiteralSelf TypeAliasTypeVarcastfinaloverload) Timestamplib)rank_1d)NA) AnyArrayLike ArrayLike IndexLabelIntervalClosedTypeListLikeNDFrameTPositionalIndexer RandomState RankMethod RankNaOptionnpt)function)AbstractMethodError DataErrorPandas4Warning)cache_readonly)find_stack_level)coerce_indexer_dtypeensure_dtype_can_hold_na) is_bool is_bool_dtype is_hashable is_integeris_integer_dtype is_list_likeis_numeric_dtypeis_object_dtype is_scalaris_string_dtype pandas_dtype)isnana_value_for_dtypenotna) algorithmssample)executor)ArrowExtensionArrayBaseMaskedArrayExtensionArray IntegerArray) StringDtype)ArrowStringArray) PandasObjectSelectionMixin) DataFrame)NDFrame)basenumba_ops) get_grouper)GroupByIndexingMixinGroupByNthSelector)Index MultiIndex default_index)ensure_block_shape)Series)get_group_index_sorter)get_jit_argumentsmaybe_use_numbaprepare_function_arguments) BaseOffset) Timedelta)AnyLevelPTTimedeltaConvertibleTypesTimestampConvertibleTypes) BaseIndexer) Resampler)ExpandingGroupByExponentialMovingWindowGroupByRollingGroupByc&eZdZdZddZdZddZy) GroupByPlotzE Class implementing the .plot attribute for groupby objects. c||_yN)_groupby)selfgroupbys f/var/www/html/python-recuperauto-other/env/lib/python3.12/site-packages/pandas/core/groupby/groupby.py__init__zGroupByPlot.__init__s  cVfd}d|_|jj|S)Nc(|jiSrf)plot)rhkeyargskwargss rjfzGroupByPlot.__call__..fs499d-f- -rlro)__name__rg_python_apply_plot)rhrqrrrss `` rj__call__zGroupByPlot.__call__s& . }}//22rlcfd}|S)NcLfd}jj|S)Ncj}dk(r#jdr|jd|t|ji|S)Nscatterlegendlabel)copyget setdefaultgetattrro)rhrp local_kwargsrqrrnames rjrsz0GroupByPlot.__getattr__..attr..fsN%{{} 9$H)= ++GS9/wtyy$/FFFrl)rgru)rqrrrsrrhs`` rjattrz%GroupByPlot.__getattr__..attrs  G==33A6 6rl)rhrrs`` rj __getattr__zGroupByPlot.__getattr__s 7 rlN)riGroupByreturnNonerstr)rt __module__ __qualname____doc__rkrvrrrlrjrdrds 3 rlrdr _KeysArgTypeceZdZUejhdzZded<dZded<dZded<d ed <edd Z edd Z ee dd Z ee ddZ ee ddZedZeedZeddZe ddZe ddZ ddZed dZed!dZy)" BaseGroupBy> objkeyssortleveldropnagrouperas_indexobserved exclusions group_keysops.BaseGrouper_grouperN_KeysArgType | NonerIndexLabel | Nonerboolrc.|jjSrfrngroupsrhs rj__len__zBaseGroupBy.__len__s}}$$$rlc,tj|Srf)object__repr__rs rjrzBaseGroupBy.__repr__st$$rlct|jtr]t|jdk(rEt j d|jdd|jddt t|jjS)aQ Dict {group name -> group labels}. This property provides a dictionary representation of the groupings formed during a groupby operation, where each key represents a unique group value from the specified column(s), and each value is a list of index labels that belong to that group. See Also -------- core.groupby.DataFrameGroupBy.get_group : Retrieve group from a ``DataFrameGroupBy`` object with provided name. core.groupby.SeriesGroupBy.get_group : Retrieve group from a ``SeriesGroupBy`` object with provided name. core.resample.Resampler.get_group : Retrieve group from a ``Resampler`` object with provided name. Examples -------- For SeriesGroupBy: >>> lst = ["a", "a", "b"] >>> ser = pd.Series([1, 2, 3], index=lst) >>> ser a 1 a 2 b 3 dtype: int64 >>> ser.groupby(level=0).groups {'a': ['a', 'a'], 'b': ['b']} For DataFrameGroupBy: >>> data = [[1, 2, 3], [1, 5, 6], [7, 8, 9]] >>> df = pd.DataFrame(data, columns=["a", "b", "c"]) >>> df a b c 0 1 2 3 1 1 5 6 2 7 8 9 >>> df.groupby(by="a").groups {1: [0, 1], 7: [2]} For Resampler: >>> ser = pd.Series( ... [1, 2, 3, 4], ... index=pd.DatetimeIndex( ... ["2023-01-01", "2023-01-15", "2023-02-01", "2023-02-15"] ... ), ... ) >>> ser 2023-01-01 1 2023-01-15 2 2023-02-01 3 2023-02-15 4 dtype: int64 >>> ser.resample("MS").groups {Timestamp('2023-01-01 00:00:00'): np.int64(2), Timestamp('2023-02-01 00:00:00'): np.int64(4)} zWIn a future version, the keys of `groups` will be a tuple with a single element, e.g. (rz,) , instead of a scalar, e.g. z, when grouping by a list with a single element. Use ``df.groupby(by='a').groups`` instead of ``df.groupby(by=['a']).groups`` to avoid this warning stacklevel) isinstancerlistlenwarningswarnr'r)rgroupsrs rjrzBaseGroupBy.groupss|B dii &3tyy>Q+> MM66:iil^D--1YYq\N;SS +- }}###rlc.|jjSrfrrs rjrzBaseGroupBy.ngroups/s}}$$$rlc.|jjS)ak Dict {group name -> group indices}. The dictionary keys represent the group labels (e.g., timestamps for a time-based resampling operation), and the values are arrays of integer positions indicating where the elements of each group are located in the original data. This property is particularly useful when working with resampled data, as it provides insight into how the original time-series data has been grouped. See Also -------- core.groupby.DataFrameGroupBy.indices : Provides a mapping of group rows to positions of the elements. core.groupby.SeriesGroupBy.indices : Provides a mapping of group rows to positions of the elements. core.resample.Resampler.indices : Provides a mapping of group rows to positions of the elements. Examples -------- For SeriesGroupBy: >>> lst = ["a", "a", "b"] >>> ser = pd.Series([1, 2, 3], index=lst) >>> ser a 1 a 2 b 3 dtype: int64 >>> ser.groupby(level=0).indices {'a': array([0, 1]), 'b': array([2])} For DataFrameGroupBy: >>> data = [[1, 2, 3], [1, 5, 6], [7, 8, 9]] >>> df = pd.DataFrame( ... data, columns=["a", "b", "c"], index=["owl", "toucan", "eagle"] ... ) >>> df a b c owl 1 2 3 toucan 1 5 6 eagle 7 8 9 >>> df.groupby(by=["a"]).indices {np.int64(1): array([0, 1]), np.int64(7): array([2])} For Resampler: >>> ser = pd.Series( ... [1, 2, 3, 4], ... index=pd.DatetimeIndex( ... ["2023-01-01", "2023-01-15", "2023-02-01", "2023-02-15"] ... ), ... ) >>> ser 2023-01-01 1 2023-01-15 2 2023-02-01 3 2023-02-15 4 dtype: int64 >>> ser.resample("MS").indices defaultdict(, {Timestamp('2023-01-01 00:00:00'): [0, 1], Timestamp('2023-02-01 00:00:00'): [2, 3]}) )rindicesrs rjrzBaseGroupBy.indices4sJ}}$$$rlcdt|r*|jjtjgSt |t rt d|D}t|jdkDrtt|j}nd}t |t rnt |t s d}t|t|t|k(s |j|Sfd|D}t dt||d D}n|}||}|jj|gS#t$r}d}t||d}~wwxYw) zd Safe get multiple indices, translate keys for datelike to underlying repr. c|t|tjrdSt|tjrdSdS)Nct|Srf)rrps rjz?BaseGroupBy._get_index..get_converter..s 9S>rlc,t|jSrf)rasm8rs rjrz?BaseGroupBy._get_index..get_converter..s9S>#6#6rlc|Srfrrs rjrz?BaseGroupBy._get_index..get_converter..s3rl)rdatetimenp datetime64)ss rj get_converterz-BaseGroupBy._get_index..get_converters4!X../11Ar}}-66&&rlc3VK|]!}t|rtjn|#ywrf)r7rnan).0comps rj z)BaseGroupBy._get_index..sID4:47Is')rNz.sAq-*Asc32K|]\}}||ywrfr)rrsns rjrz)BaseGroupBy._get_index..sM$!Q1MsTstrict) r7rr~rrrtuplernextiter ValueErrorKeyErrorzip)rhr index_samplemsgerr converters converterrs @rj _get_indexzBaseGroupBy._get_index{s1 ' :<<##BFFB/ / dE "IDIID t|| q T\\ 23LL lE *dE*T o%t9L 11 3<<--BLAJM#j$t*LMMD%l3IT?D||b)) 36%S/s2 3sD?? EEEct|jtr |jS|j:t |jr|j|jS|j S|jSrf)rrrQ _selectionr._obj_with_exclusionsrs rj _selected_objzBaseGroupBy._selected_objs] dhh '88O ?? &4??+xx00 ,, ,xxrlc6|jjSrf)r_dir_additionsrs rjrzBaseGroupBy._dir_additionssxx&&((rlcyrfrrhfuncrqrrs rjpipezBaseGroupBy.pipe rlcyrfrrs rjrzBaseGroupBy.piperrlc6tj||g|i|S)a Apply a ``func`` with arguments to this GroupBy object and return its result. Use `.pipe` when you want to improve readability by chaining together functions that expect Series, DataFrames, GroupBy or Resampler objects. Instead of writing >>> h = lambda x, arg2, arg3: x + 1 - arg2 * arg3 >>> g = lambda x, arg1: x * 5 / arg1 >>> f = lambda x: x**4 >>> df = pd.DataFrame([["a", 4], ["b", 5]], columns=["group", "value"]) >>> h(g(f(df.groupby("group")), arg1=1), arg2=2, arg3=3) # doctest: +SKIP You can write >>> ( ... df.groupby("group").pipe(f).pipe(g, arg1=1).pipe(h, arg2=2, arg3=3) ... ) # doctest: +SKIP which is much more readable. Parameters ---------- func : callable or tuple of (callable, str) Function to apply to this GroupBy object or, alternatively, a `(callable, data_keyword)` tuple where `data_keyword` is a string indicating the keyword of `callable` that expects the GroupBy object. *args : iterable, optional Positional arguments passed into `func`. **kwargs : dict, optional A dictionary of keyword arguments passed into `func`. Returns ------- GroupBy The return type of `func`. See Also -------- Series.pipe : Apply a function with arguments to a series. DataFrame.pipe : Apply a function with arguments to a dataframe. apply : Apply function to each group instead of to the full GroupBy object. Notes ----- See more `here `_ Examples -------- >>> df = pd.DataFrame({"A": "a b a b".split(), "B": [1, 2, 3, 4]}) >>> df A B 0 a 1 1 b 2 2 a 3 3 b 4 To get the difference between each groups maximum and minimum value in one pass, you can do >>> df.groupby("A").pipe(lambda x: x.max() - x.min()) B A a 2 b 2 )comrrs rjrzBaseGroupBy.pipes Vxxd4T4V44rlct|j}|j}t|rt|dk(st|r=t|dk(r/t |t rt|dk(r|d}n t ||j|}t|s t ||jj|S)a Construct DataFrame from group with provided name. This method retrieves all rows belonging to a specific group identified by the given name. Parameters ---------- name : object The name of the group to get as a DataFrame. Returns ------- Series or DataFrame Get the respective Series or DataFrame corresponding to the group provided. See Also -------- DataFrameGroupBy.groups: Dictionary representation of the groupings formed during a groupby operation. DataFrameGroupBy.indices: Provides a mapping of group rows to positions of the elements. SeriesGroupBy.groups: Dictionary representation of the groupings formed during a groupby operation. SeriesGroupBy.indices: Provides a mapping of group rows to positions of the elements. Examples -------- For SeriesGroupBy: >>> lst = ["a", "a", "b"] >>> ser = pd.Series([1, 2, 3], index=lst) >>> ser a 1 a 2 b 3 dtype: int64 >>> ser.groupby(level=0).get_group("a") a 1 a 2 dtype: int64 For DataFrameGroupBy: >>> data = [[1, 2, 3], [1, 5, 6], [7, 8, 9]] >>> df = pd.DataFrame( ... data, columns=["a", "b", "c"], index=["owl", "toucan", "eagle"] ... ) >>> df a b c owl 1 2 3 toucan 1 5 6 eagle 7 8 9 >>> df.groupby(by=["a"]).get_group((1,)) a b c owl 1 2 3 toucan 1 5 6 For Resampler: >>> ser = pd.Series( ... [1, 2, 3, 4], ... index=pd.DatetimeIndex( ... ["2023-01-01", "2023-01-15", "2023-02-01", "2023-02-15"] ... ), ... ) >>> ser 2023-01-01 1 2023-01-15 2 2023-02-01 3 2023-02-15 4 dtype: int64 >>> ser.resample("MS").get_group("2023-01-01") 2023-01-01 1 2023-01-15 2 dtype: int64 rr) rrr1rrrrrriloc)rhrrrindss rj get_groupzBaseGroupBy.get_group$sbyy   CJ!O  3t9>$&3t9>Awtn$t$4y4. !!&&t,,rlc|j}|j}|jj|j}t |rt |dk(st|trt |dk(r d|D}|S)a Groupby iterator. This method provides an iterator over the groups created by the ``resample`` or ``groupby`` operation on the object. The method yields tuples where the first element is the label (group key) corresponding to each group or resampled bin, and the second element is the subset of the data that falls within that group or bin. Returns ------- Iterator Generator yielding a sequence of (name, subsetted object) for each group. See Also -------- Series.groupby : Group data by a specific key or column. DataFrame.groupby : Group DataFrame using mapper or by columns. DataFrame.resample : Resample a DataFrame. Series.resample : Resample a Series. Examples -------- For SeriesGroupBy: >>> lst = ["a", "a", "b"] >>> ser = pd.Series([1, 2, 3], index=lst) >>> ser a 1 a 2 b 3 dtype: int64 >>> for x, y in ser.groupby(level=0): ... print(f"{x}\n{y}\n") a a 1 a 2 dtype: int64 b b 3 dtype: int64 For DataFrameGroupBy: >>> data = [[1, 2, 3], [1, 5, 6], [7, 8, 9]] >>> df = pd.DataFrame(data, columns=["a", "b", "c"]) >>> df a b c 0 1 2 3 1 1 5 6 2 7 8 9 >>> for x, y in df.groupby(by=["a"]): ... print(f"{x}\n{y}\n") (1,) a b c 0 1 2 3 1 1 5 6 (7,) a b c 2 7 8 9 For Resampler: >>> ser = pd.Series( ... [1, 2, 3, 4], ... index=pd.DatetimeIndex( ... ["2023-01-01", "2023-01-15", "2023-02-01", "2023-02-15"] ... ), ... ) >>> ser 2023-01-01 1 2023-01-15 2 2023-02-01 3 2023-02-15 4 dtype: int64 >>> for x, y in ser.resample("MS"): ... print(f"{x}\n{y}\n") 2023-01-01 00:00:00 2023-01-01 1 2023-01-15 2 dtype: int64 2023-02-01 00:00:00 2023-02-01 3 2023-02-15 4 dtype: int64 rc3,K|] \}}|f|fywrfr)rrpgroups rjrz'BaseGroupBy.__iter__..s?*#uvuo?s) rrr get_iteratorrr1rrr)rhrrresults rj__iter__zBaseGroupBy.__iter__sityy ++D,>,>?  CJ!O tT "s4yA~@?F rl)rint)rr)rzdict[Hashable, Index])rz$dict[Hashable, npt.NDArray[np.intp]])rzset[str])rz!Callable[Concatenate[Self, P], T]rqzP.argsrrzP.kwargsrr[)rztuple[Callable[..., T], str]rqrXrrrXrr[)rz@Callable[Concatenate[Self, P], T] | tuple[Callable[..., T], str]rqrXrrrXrr[rDataFrame | Series)rz#Iterator[tuple[Hashable, NDFrameT]])rtrrrC _hidden_attrs__annotations__rrrrrpropertyrrrrr(rrrrrrrrlrjrrs .. 2 M $D $#E # % % % %  I$ I$V  % %  C% C%J 0* 0*d  & ) )/  *  K5NK5K5 K5 K5Z _- _-B b brlrOutputFrameOrSeries)boundcleZdZUdZded<ded<e dP dQdZdRdZedSd Ze dT dUd Z e dVd Z e dW dXd Z e dW dYdZ dT dZdZ ed[dZ d\dZedddZedddZd dd]dZe d^ d_dZed`dZ dadZe db dcdZdddedZeddddZeddddZedfdZed Zedgdhd!Zeedid"Zedgdjd#Zedgdjd$Z edkd%Z!e dl dmd&Z"edndod'Z#e dp dqd)Z$e dp dqd*Z%e dr dsd+Z&e dt dud,Z'edvd-Z(e dw dxd.Z)e dy dzd/Z*e d{ dxd0Z+e d{ dxd1Z,e d| dzd2Z-e d| dzd3Z.ed}d4Z/ d~ dkd5Z0e dd d dd6Z1e d dd7Z2e d dd8Z3e d dd9Z4edWdd:Z5edWdd;Z6edWdd<Z7eedd=Z8 dW dd>Z9e d dd?Z:edgdd@Z;edgddAZe dn dodDZ?e dn dodEZ@e dn dodFZAed(deBjdf ddGZDe d ddHZEe d ddIZFedddJZGedddKZHeddLZIe d ddMZJ d ddNZK ddOZLy)rat Class for grouping and aggregating relational data. See aggregate, transform, and apply functions on this object. It's easiest to use obj.groupby(...) to use GroupBy, but you can also do: :: grouped = groupby(obj, ...) Parameters ---------- obj : pandas object level : int, default None Level of MultiIndex groupings : list of Grouping objects Most users should ignore this exclusions : array-like, optional List of columns to exclude name : str Most users should ignore this Returns ------- **Attributes** groups : dict {group name -> group labels} len(grouped) : int Number of groups Notes ----- After grouping, see aggregate, apply, and transform functions. Here are some other brief notes about usage. When grouping by multiple groups, the result index will be a MultiIndex (hierarchical) by default. Iteration produces (key, group) tuples, i.e. chunking the data by group. So you can write code like: :: grouped = obj.groupby(keys) for key, group in grouped: # do something with the data Function calls on GroupBy, if not specially implemented, "dispatch" to the grouped data. So if you group a DataFrame and wish to invoke the std() method on each group, you can simply do: :: df.groupby(mapper).std() rather than :: df.groupby(mapper).aggregate(np.std) You can pass arguments to these "wrapped" functions, too. See the online documentation for full exposition on these topics and much more rrrrNc V||_t|tsJt|||_||_||_||_| |_| |_ |t||||| |j\}}}| |_ ||_ ||_ |rt||_yt|_y)N)rrrr)rrrFtyperrrrrrrJrrr frozensetr) rhrrrrr selectionrrrrrs rjrkzGroupBy.__init__6s$#w'2c2'     $ ?'2!{{ ( $GZ!  3=)J/9;rlc||jvrtj||S||jvr||St dt |j d|d)N'z' object has no attribute ')_internal_names_setr__getattribute__rAttributeErrorrrt)rhrs rjrzGroupBy.__getattr___sd 4++ +**46 6 488 : T ##$$?vQ G  rlcdtt|j|dfd }||_|tj vr|j |S|tjv}|j||j|| }|jjr|r|j|}|S)z.curriednsQ((( (rl) is_transformnot_indexed_samerf) rrrrtrGplotting_methodsrutransformation_kernels_python_apply_generalrhas_dropped_na_set_result_index_ordered)rhrrqrrrrrrss `` @rj _op_via_applyzGroupBy._op_via_applyis D223T : )   4(( (**73 3t::: ++   % %%!-- ,  == ' 'L33F;F rlFcddlm}|jrj|sh|jrQ|jj }|jj }|jj}||d|||d}n||d}n|s||d}|jj} |jr |jj} | dk7} | | } | jro|jdj| sQtj | j"} |jj%| \} }|j'| d}n|j)| d}n ||d}|j*j,dk(r|j*j.}n$t1|j2r |j2}nd}t5|t6r |||_|j9|j*d S) NrconcatF)axisrlevelsnamesrrrrimethod)pandas.core.reshape.concatrrrr result_indexrrrindexridshas_duplicatesaxesequalsr:unique1d_valuesget_indexer_non_uniquetakereindexrndimrr.rrrQ __finalize__)rhvaluesrrrr group_levels group_namesraxlabelsmasktargetindexer_rs rj_concat_objectszGroupBy._concat_objectss 6 ??<}}!]]77 #}}33 "mm11 #'%  Q/!F+F##))B{{**|X  Q)>)>r)B#,,RZZ8#\\@@H W153F+F 88==A 88==D  )??DD ff %$*:FK""488I">>rlc|jj}|jjr+|jjs|j |d}|St |jjd}|j |d}|jd}|jjr%|jtt|d}|j |d}|S)NrrFr}) rrr is_monotonicr set_axisrM result_ilocs sort_indexr#rOr)rhrroriginal_positionss rjr z!GroupBy._set_result_index_ordereds == % %dmm.J.J__U_3FM#4==#=#=EJ!3!<"""* == ' '^^M#e*$=A^FFQ/ rlc ttrjt|jj }d fd }|Ej d|d|tj|tt|zttt|jj|jjdD]\}\}}||dk(r|dn d||z dz }|jvs.|j d|||Jj d||ttj |t|d S) Nctjtr0t|ts |fdjjdz zzS|S)N)r)rcolumnsrNrnlevels)rrs rjfull_keyz0GroupBy._insert_inaxis_grouper..full_keysB&..*5ju>Uw&..*@*@1*D!EEEKrlrlevel_TrrrFr1)rrrr)rrQto_framerr groupingsinsertrtile enumeraterreversedrget_group_levelsr:rMrepeat)rhrqs n_groupingsr<rrlevs ` rj_insert_inaxis_grouperzGroupBy._insert_inaxis_groupersP ff %__&F$--112   > MM8f[M23RWWRVPSTVPWAW5X  #, ,,- ..0 #   E;D#|#a'BJ!+"5"9!:;6>>):MM!Xd^S9MM8D>53B1Hu+U- 4 rlc|js>|j||}|j}tt ||_|S|j j}| t||}||_|S)z Wraps the output of GroupBy aggregations into the expected result. Parameters ---------- result : Series, DataFrame Returns ------- Series or DataFrame rF) rrI _consolidaterOrrrr_insert_quantile_level)rhrrFrs rj_wrap_aggregated_outputzGroupBy._wrap_aggregated_outputsw(}}00B0?F((*F(V5FL MM..E~/ub9 FL rlct|rfr%)rhdatar&rrs rj_wrap_applied_outputzGroupBy._wrap_applied_output=s"$''rlc>|jj}|jj}|jj}|j |dj }|j }t|trat|jjdkDr td|jjdj}|j|}|j |j }tj||\} } | | ||fS)Nrrrz_Grouping with more than 1 grouping labels and a MultiIndex is not supported with engine='numba')rrr4 _sorted_idsr"to_numpyrrrNrr?NotImplementedErrorrget_level_valuesrgenerate_slices) rhrQr sorted_index sorted_ids sorted_data index_data group_keysorted_index_datastartsendss rj _numba_prepzGroupBy._numba_prepIs--''}}11 ]].. ii 1i5>>@ ZZ j* -4==**+a/)H //277I#44Y?J&OOL9BBD**:w?        rlc p|js td|j}|jdk(r|n|j }t j ||dfit|}|jj}|jj} |jj|f|| d|} |jj| jd<|j| | j} |jdk(r$| j!d} |j"| _| S|j$| _| S)zp Perform groupby with a standard numerical aggregation function (e.g. mean) with Numba. zr<generate_shared_aggregatorrSrrr_mgrapplyrr_constructor_from_mgrsqueezerr:) rhr dtype_mapping engine_kwargsaggregator_kwargsrQdf aggregatorrrres_mgrrs rj_numba_agg_generalzGroupBy._numba_agg_generalds}}%N ((YY!^T88     .  mm--''"''--  "G 7H --44 Q))' )E 99>^^I.F))FK "\\FN rl)rjc |j}|jj}|jdk(r|n|j }|j |\}} } } t j|t|||d\}}t j|fit|} | | | || t|jg|} | jtj|d} |j }|jdk(rd|j"i}| j%} nd|ji}|j&| fd|i|S) a( Perform groupby transform routine with the numba engine. This routine mimics the data splitting routine of the DataSplitter class to generate the indices of each group in the sorted data and then passes the data and indices into a Numba jitted function. rcnum_required_argsrrrrr:r)rrr4r$r>rarH validate_udfrUgenerate_numba_transform_funcrSrr:r"rargsortrrravel _constructor)rhrrjrqrrrQ index_sortingrlr_r`rYr[numba_transform_funcrr result_kwargss rj_transform_with_numbazGroupBy._transform_with_numbas8(( 22 YY!^T262B2B22F/lKD!1 $! f &CC  %m4 &      O    RZZ 6Q?  99>#TYY/M\\^F& 5M t  FuF FFrlc |j}|jdk(r|n|j}|j|\}}} } t j |t |||d\}}t j|fit|} | | | ||t|jg|} |jj} |jdk(rd|ji}| j} nd|ji}|j| fd| i|}|j s*|j#|}t%t||_|S)a* Perform groupby aggregation routine with the numba engine. This routine mimics the data splitting routine of the DataSplitter class to generate the indices of each group in the sorted data and then passes the data and indices into a Numba jitted function. rcrqrrr:r)rr$r>rarHrsrUgenerate_numba_agg_funcrSrr:rrrrvrwrrIrOr)rhrrjrqrrrQrlr_r`rYr[numba_agg_funcrrrzress rj_aggregate_with_numbazGroupBy._aggregate_with_numbas>((YY!^T262B2B22F/lKD!1 $! f 77  %m4       O     ** 99>#TYY/M\\^F& 5MdEeE}E}}--c2C%c#h/CI rl)include_groupscz|r tdttrNt|r3t |}t |r|iSsrtd|St ddsr,t rtfd}n td}|j||jS)aS Apply function ``func`` group-wise and combine the results together. The function passed to ``apply`` must take a dataframe 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 dataframe 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``. include_groups : bool, default False When True, will attempt to apply ``func`` to the groupings in the case that they are columns of the DataFrame. If this raises a TypeError, the result will be computed with the groupings excluded. When False, the groupings will be excluded when applying ``func``. .. versionadded:: 2.2.0 .. versionchanged:: 3.0.0 The default changed from True to False, and True is no longer allowed. **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 ----- See :ref:`groupby.apply` in the User Guide for more details and examples. 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. Each group passed to ``func`` has a ``name`` attribute set to the group key (the value of the grouping for that group). This is useful for identifying the current group, for example when grouping by an external grouper rather than by a column of the object. Examples -------- >>> df = pd.DataFrame({"A": "a a b".split(), "B": [1, 2, 3], "C": [4, 6, 5]}) >>> g1 = df.groupby("A", group_keys=False) >>> g2 = df.groupby("A", group_keys=True) Notice that ``g1`` and ``g2`` have two groups, ``a`` and ``b``, and only differ in their ``group_keys`` argument. Calling `apply` in various ways, we can get different grouping results: Example 1: below the function passed to `apply` takes a DataFrame as its argument and returns a DataFrame. `apply` combines the result for each group together into a new DataFrame: >>> g1[["B", "C"]].apply(lambda x: x / x.sum()) B C 0 0.333333 0.4 1 0.666667 0.6 2 1.000000 1.0 In the above, the groups are not part of the index. We can have them included by using ``g2`` where ``group_keys=True``: >>> g2[["B", "C"]].apply(lambda x: x / x.sum()) B C A a 0 0.333333 0.4 1 0.666667 0.6 b 2 1.000000 1.0 Example 2: The function passed to `apply` takes a DataFrame as its argument and returns a Series. `apply` combines the result for each group together into a new DataFrame. The resulting dtype will reflect the return value of the passed ``func``. >>> g1[["B", "C"]].apply(lambda x: x.astype(float).max() - x.min()) B C A a 1.0 2.0 b 0.0 0.0 >>> g2[["B", "C"]].apply(lambda x: x.astype(float).max() - x.min()) B C A a 1.0 2.0 b 0.0 0.0 The ``group_keys`` argument has no effect here because the result is not like-indexed (i.e. :ref:`a transform `) when compared to the input. Example 3: The function passed to `apply` takes a DataFrame as its argument and returns a scalar. `apply` combines the result for each group together into a Series, including setting the index as appropriate: >>> g1.apply(lambda x: x.C.max() - x.B.min()) A a 5 b 2 dtype: int64 Example 4: The function passed to ``apply`` returns ``None`` for one of the group. This group is filtered from the result: >>> g1.apply(lambda x: None if x.iloc[0, 0] == 3 else x) B C 0 1 4 1 2 6 )include_groups=True is no longer allowed.z"Cannot pass arguments to property z$apply func should be callable, not 'rc|giSrfr)grqrrrs rjrszGroupBy.apply..fs3D3F33rlz6func must be a callable if args or kwargs are supplied) rrrhasattrrcallable TypeErrorr r r)rhrrrqrrrrss ` `` rjrfz GroupBy.applys\ HI I dC tT"dD)C=///V$'I$%PQQ  "FtfA NOO V~t44!LA))!T-F-FGGrlcp|jj||\}}||}|j||||S)a Apply function f in python space Parameters ---------- f : callable Function to apply data : Series or DataFrame Data to apply f to not_indexed_same: bool, optional When specified, overrides the value of not_indexed_same. Apply behaves differently when the result index is equal to the input index, but this can be coincidental leading to value-dependent behavior. is_transform : bool, default False Indicator for whether the function is actually a transform and should not have group keys prepended. Returns ------- Series or DataFrame data after applying f )rapply_groupwiserR)rhrsrQrrr&mutateds rjr zGroupBy._python_apply_generalsI<--774@  #& ((       rlc|j}g}|jj|D]3\}}|jdk(r||_|j |||5|j ||dS)a_ Apply a plotting function f group-wise. Each Series group gets its group key as the name, which plotting methods use for legend labels. Unlike the general apply path, this labels the group explicitly rather than relying on the name attribute being pinned to the group key as a side effect (GH#41090). rTr)rrrr$rappendrR)rhrsrQr&rprs rjruzGroupBy._python_apply_plotst!!--44T: )JCzzQ  MM!E3- ( ) ((v(MMrlcJ|J|jdk(rt|d}nHt|j|j}|j ddk(sJ|j dddf} |jj||}|j} | tk(r|jtd}n.t| r#| j} | j|| }t!|| S#t$r*}d|d|jd } t|| |d}~wwxYw) zn Fallback to pure-python aggregation if _cython_operation raises NotImplementedError. NrFr1dtyperzagg function failed [how->z,dtype->])r$)r$rQrEr[rshaperr agg_series Exceptionrrastyper5construct_array_type_from_sequencerP) rhhowr&r$altserrl res_valuesrrrstring_array_clss rj_agg_py_fallbackzGroupBy._agg_py_fallbacks  ;;! e,C6886<<8B88A;!# ##''!Q$-C  *11#s;J   F?#**6*>J U #$99; )8858QJ "*488# *.se8CII;aHC$s)C.c ) *s+C// D"8%DD"c L t|s tdj| d  fd } j|}j |}dvrj |d}j |} | jjdS) Nz(numeric_only accepts only Boolean values numeric_onlyrctdvxr"|jtjdk(}|r dk(rdnd}n}  jj||fjdz d }|rr|jj dk(rYdk(rd nd }tj tj||tj|jt}|S#t$r,}d vrtd |jd |Yd}~nd}~wwxYwJ j|j}|S)Nanyallrrmaxminrr min_countrsg?)rrstdsemz is not supported for z dtype)r$r)rrr_cython_operationr$kindwhereisnanasarrayrrrVrr) r&use_bool_fastpath_howrfillrrrQrrrrrhs rj array_funcz/GroupBy._cython_agg_general..array_func s]!$~ 5!&,,"((K; ! #u u% 888Q'   "%):):c)A"%,3CDXX($ 60BfTl '  ;#)E"E#%5fll^6J#F  "? "?**3TYYC*PFMs.C D&"D  Didxminidxmaxskipna)rrrirr&rrr) r,r_get_data_to_aggregategrouped_reduce_wrap_agged_manager_wrap_idxmax_idxminrNr%r) rhrrrrrrrnew_mgrroutrQs ``` `` @rj_cython_agg_generalzGroupBy._cython_agg_generals|$GH H** 3*O& & P%%j1&&w/ & &**3Cx@P*QC**3/;;rlc t|rfrP)rhrrrrs rj_cython_transformzGroupBy._cython_transform;s !$''rlenginerjct|ts|j|||g|i|S|tjvrd|d}t ||tj vs|tjvr| ||d<||d<t|||i|S|jr|j|g|||d|Stj|dd5tj|d|jj5|j|g|||d|cdddcdddS#1swYnxYwdddy#1swYyxYw) Nrz2' is not a valid function name for transform(name)rrjrrTr)rr_transform_generalrGtransform_kernel_allowlistrcythonized_kernelsr rr_reduction_kernel_transformr temp_setattrrobserved_grouper)rhrrrjrqrrrs rj _transformzGroupBy._transform>sn$$*4**4XXQWX X 88 8dVMNCS/ ! T,, ,8S8S0S!#)x *7'&74&77 7}}7t77(.mOU   z48   z4==3Q3QR 8t77(.mOU        s$ ,D76D" D7"D+ 'D77Ectj|dd5|dvr$td|}|j|dg|i|}n| ||d<||d<t |||i|}ddd|j S#1swYxYw)NrTrzLiteral['idxmin', 'idxmax']rrj)rrr_idxmax_idxminr_wrap_transform_fast_result)rhrrrjrqrrrs rjrz#GroupBy._reduction_kernel_transform]s  dJ 5 >++94@,,,T4I$I&I%'-F8$.;F?+,t,d=f= >//77 > >s AA88Bc(|j}|jj}|j|jjd}|j j dk(r`tj|j||jj}|j||j|j}|S|jj|}|jd||fid}|j!|jd}|S)z7 Fast transform path for aggregations. rrr) allow_fillrrT) allow_dups)rrrr#rrr$r:take_ndr r rwrrr"_reindex_with_indexersr3)rhrrrroutputnew_axs rjrz#GroupBy._wrap_transform_fast_resultss ''mm : :C 88==A $$ 0L0LC%%c%JF \\&&s+F22A}3ERV2WF__SYYQ_7F rlcRt|dk(rtjgd}n(tjtj|}|r|j j |d}|Stjt|j jt}|jdd||jt<tj|g|j jdddj}|j j!|}|S)Nrint64rrFTr)rrarrayr concatenaterr"emptyrrrrrrArr[r)rhrrfilteredr+s rj _apply_filterzGroupBy._apply_filters w<1 hhr1GggbnnW56G ))..wQ.?H 88C 2 2 8 89FD IIe (,D$ %774!C4#5#5#;#;AB#?!C!CDFFD))//5Hrlc|jj}|jj}t||}||t |}}|dk(r%t j dt jSt jd|dd|ddk7f}t jt jt j|d|f}|j}|r|t j|||z}n2t j|t j|dddf||z }|jjrHt j|dk(t j|j!t j"d}n!|j!t jd}t j |t j$} t j&|t j$| |<|| S) a. Parameters ---------- ascending : bool, default True If False, number in reverse, from length of group - 1 to 0. Notes ----- this is currently implementing sort=False (though the default is sort=True) for groupby in general rrTNrrFr1)rrrrRrrrrr_diffnonzerocumsumrEr rrrfloat64intparange) rh ascendingrrsortercountrunreprrevs rj_cumcount_arrayzGroupBy._cumcount_arraysmm--'''W5[#c(U A:88ARXX. .eeD#cr(c!"g--.ggbeeBJJsOA.567tmmo  299SXs+ +C))Cc!"gtm 45s;cAC == ' '((3"9bffcjj%j.PQC**RXXE*2ChhuBGG,iiRWW5F 3xrlct|jtr|jjSt|jtsJ|jj Srf)rrrE_constructor_slicedrQrwrs rj_obj_1d_constructorzGroupBy._obj_1d_constructorsF dhh *88// /$((F+++xx$$$rlc2|jdfdS)a Return True if any value in the group is truthful, else False. This is equivalent to calling ``bool`` on each value in the group and returning ``True`` if at least one is truthful. Parameters ---------- skipna : bool, default True Flag to ignore nan values during truth testing. Returns ------- Series or DataFrame DataFrame or Series of boolean values, where a value is True if any element is True within its respective group, False otherwise. See Also -------- Series.any : Apply function any to a Series. DataFrame.any : Apply function any to each row or column of a DataFrame. Examples -------- For SeriesGroupBy: >>> lst = ["a", "a", "b"] >>> ser = pd.Series([1, 2, 0], index=lst) >>> ser a 1 a 2 b 0 dtype: int64 >>> ser.groupby(level=0).any() a True b False dtype: bool For DataFrameGroupBy: >>> data = [[1, 0, 3], [1, 0, 6], [7, 1, 9]] >>> df = pd.DataFrame( ... data, columns=["a", "b", "c"], index=["ostrich", "penguin", "parrot"] ... ) >>> df a b c ostrich 1 0 3 penguin 1 0 6 parrot 7 1 9 >>> df.groupby(by=["a"]).any() b c a 1 False True 7 True True rc>t|djSNFr1r)rQrrrs rjrzGroupBy.any..&/3363Brlrrrrhrs `rjrz GroupBy.anys'r'' B(  rlc2|jdfdS)a Return True if all values in the group are truthful, else False. This is equivalent to calling ``bool`` on each value in the group and returning ``True`` only if all are truthful. Parameters ---------- skipna : bool, default True Flag to ignore nan values during truth testing. Returns ------- Series or DataFrame DataFrame or Series of boolean values, where a value is True if all elements are True within its respective group, False otherwise. See Also -------- Series.all : Apply function all to a Series. DataFrame.all : Apply function all to each row or column of a DataFrame. Examples -------- For SeriesGroupBy: >>> lst = ["a", "a", "b"] >>> ser = pd.Series([1, 2, 0], index=lst) >>> ser a 1 a 2 b 0 dtype: int64 >>> ser.groupby(level=0).all() a True b False dtype: bool For DataFrameGroupBy: >>> data = [[1, 0, 3], [1, 5, 6], [7, 8, 9]] >>> df = pd.DataFrame( ... data, columns=["a", "b", "c"], index=["ostrich", "penguin", "parrot"] ... ) >>> df a b c ostrich 1 0 3 penguin 1 5 6 parrot 7 8 9 >>> df.groupby(by=["a"]).all() b c a 1 False True 7 True True rc>t|djSr)rQrrs rjrzGroupBy.all..Orrlrrrs `rjrz GroupBy.alls't'' B(  rlc& |j}|jj|jj dk7|jdk(d fd }|j |}|j |}|j|}|S)a~ Compute count of group, excluding missing values. Returns the number of non-NA/null observations per group. Returns ------- Series or DataFrame Count of values within each group. See Also -------- Series.count : Apply function count to a Series. DataFrame.count : Apply function count to each row or column of a DataFrame. Examples -------- For SeriesGroupBy: >>> lst = ["a", "a", "b"] >>> ser = pd.Series([1, 2, np.nan], index=lst) >>> ser a 1.0 a 2.0 b NaN dtype: float64 >>> ser.groupby(level=0).count() a 2 b 0 dtype: int64 For DataFrameGroupBy: >>> data = [[1, np.nan, 3], [1, np.nan, 6], [7, 8, 9]] >>> df = pd.DataFrame( ... data, columns=["a", "b", "c"], index=["cow", "horse", "bull"] ... ) >>> df a b c cow 1 NaN 3 horse 1 NaN 6 bull 7 8.0 9 >>> df.groupby("a").count() b c a 1 0 2 7 1 1 For Resampler: >>> ser = pd.Series( ... [1, 2, 3, 4], ... index=pd.DatetimeIndex( ... ["2023-01-01", "2023-01-15", "2023-02-01", "2023-02-15"] ... ), ... ) >>> ser 2023-01-01 1 2023-01-15 2 2023-02-01 3 2023-02-15 4 dtype: int64 >>> ser.resample("MS").count() 2023-01-01 2 2023-02-01 2 Freq: MS, dtype: int64 rrcT|jdk(r t|jddz}nt|z}tj|}t |t r@t|dtj|jdtjSt |trDt |jts*td}t!|j#|d|Sr*|jdk(sJ|jddk(sJ|dS|S) Nrr)r*max_binrr)r+zint64[pyarrow]rc)r$r7reshapercount_level_2drr>r@rzerosrbool_r=rrAr6rr)bvaluesmaskedcountedrr is_seriesr+rs rjhfunczGroupBy.count..hfuncs ||q g!6!6q"!= ==g.((WMG'?3#AJRXXgmmA.>bhh%OG%89* {C%%56G}33GAJe3LL||q(((}}Q'1,,,qz!Nrl)rrrr)rrrrr$rrrN) rhrQrrnew_objrrrr+rs @@@@rjrz GroupBy.countSsJ**,mm--''byIIN   0%%e,**73--g6 rlct|r*ddlm}|j|tj |dS|j dfdS)a Compute mean of groups, excluding missing values. Returns the arithmetic mean for each group. Missing values are ignored unless the entire group is NA, in which case the result for that group is NA. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. .. versionchanged:: 2.0.0 numeric_only no longer accepts ``None`` and defaults to ``False``. skipna : bool, default True Exclude NA/null values. If an entire group is NA, the result will be NA. engine : str, default None * ``'cython'`` : Runs the operation through C-extensions from cython. * ``'numba'`` : Runs the operation through JIT compiled code from numba. * ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba`` engine_kwargs : dict, default None * For ``'cython'`` engine, there are no accepted ``engine_kwargs`` * For ``'numba'`` engine, the engine can accept ``nogil`` and ``parallel`` dictionary keys. The values must either be ``True`` or ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is ``{'nogil': False, 'parallel': False}`` Returns ------- pandas.Series or pandas.DataFrame Mean of values within each group. Same object type as the caller. See Also -------- Series.mean : Apply function mean to a Series. DataFrame.mean : Apply function mean to each row or column of a DataFrame. Examples -------- >>> df = pd.DataFrame( ... {"A": [1, 1, 2, 1, 2], "B": [np.nan, 2, 3, 4, 5], "C": [1, 2, 1, 1, 2]}, ... columns=["A", "B", "C"], ... ) Groupby one column and return the mean of the remaining columns in each group. >>> df.groupby("A").mean() B C A 1 3.0 1.333333 2 4.0 1.500000 Groupby two columns and return the mean of the remaining column. >>> df.groupby(["A", "B"]).mean() C A B 1 2.0 2.0 4.0 1.0 2 3.0 1.0 5.0 2.0 Groupby one column and return the mean of only particular column in the group. >>> df.groupby("A")["B"].mean() A 1 3.0 2 4.0 Name: B, dtype: float64 r) grouped_mean min_periodsrmeanc@t|djSNFr1rr)rQrrrrs rjrzGroupBy.mean.. s#fQU388!-f9rlrrr)rTpandas.core._numba.kernelsr ror<float_dtype_mappingr)rhrrrrjr s `` rjrz GroupBy.meanshl 6 " ?**,, + ++* , rlc8|jdfdS)a. Compute median of groups, excluding missing values. For multiple groupings, the result index will be a MultiIndex Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. .. versionchanged:: 2.0.0 numeric_only no longer accepts ``None`` and defaults to False. skipna : bool, default True Exclude NA/null values. If an entire group is NA, the result will be NA. .. versionadded:: 3.0.0 Returns ------- Series or DataFrame Median of values within each group. See Also -------- Series.median : Apply function median to a Series. DataFrame.median : Apply function median to each row or column of a DataFrame. Examples -------- For SeriesGroupBy: >>> lst = ["a", "a", "a", "b", "b", "b"] >>> ser = pd.Series([7, 2, 8, 4, 3, 3], index=lst) >>> ser a 7 a 2 a 8 b 4 b 3 b 3 dtype: int64 >>> ser.groupby(level=0).median() a 7.0 b 3.0 dtype: float64 For DataFrameGroupBy: >>> data = {"a": [1, 3, 5, 7, 7, 8, 3], "b": [1, 4, 8, 4, 4, 2, 1]} >>> df = pd.DataFrame( ... data, index=["dog", "dog", "dog", "mouse", "mouse", "mouse", "mouse"] ... ) >>> df a b dog 1 1 dog 3 4 dog 5 8 mouse 7 4 mouse 7 4 mouse 8 2 mouse 3 1 >>> df.groupby(level=0).median() a b dog 3.0 4.0 mouse 7.0 3.0 For Resampler: >>> ser = pd.Series( ... [1, 2, 3, 3, 4, 5], ... index=pd.DatetimeIndex( ... [ ... "2023-01-01", ... "2023-01-10", ... "2023-01-15", ... "2023-02-01", ... "2023-02-10", ... "2023-02-15", ... ] ... ), ... ) >>> ser.resample("MS").median() 2023-01-01 2.0 2023-02-01 4.0 Freq: MS, dtype: float64 medianc@t|djSr)rQrrs rjrz GroupBy.median..s#&/66)&7rlrr)rhrrs ``rjrzGroupBy.median's.t'' & (  rlrc t|r>ddlm}tj|j |t j|dS|jdfd|S)aF Compute standard deviation of groups, excluding missing values. For multiple groupings, the result index will be a MultiIndex. Parameters ---------- ddof : int, default 1 Delta Degrees of Freedom. The divisor used in calculations is ``N - ddof``, where ``N`` represents the number of elements. engine : str, default None * ``'cython'`` : Runs the operation through C-extensions from cython. * ``'numba'`` : Runs the operation through JIT compiled code from numba. * ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba`` engine_kwargs : dict, default None * For ``'cython'`` engine, there are no accepted ``engine_kwargs`` * For ``'numba'`` engine, the engine can accept ``nogil`` and ``parallel`` dictionary keys. The values must either be ``True`` or ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is ``{'nogil': False, 'parallel': False}`` numeric_only : bool, default False Include only `float`, `int` or `boolean` data. .. versionchanged:: 2.0.0 numeric_only now defaults to ``False``. skipna : bool, default True Exclude NA/null values. If an entire group is NA, the result will be NA. .. versionadded:: 3.0.0 Returns ------- Series or DataFrame Standard deviation of values within each group. See Also -------- Series.std : Apply function std to a Series. DataFrame.std : Apply function std to each row or column of a DataFrame. Notes ----- To have the same behaviour as ``numpy.std``, use ``ddof=0`` (instead of the default ``ddof=1``) and ``skipna=False``. Examples -------- For SeriesGroupBy: >>> lst = ["a", "a", "a", "b", "b", "b"] >>> ser = pd.Series([7, 2, 8, 4, 3, 3], index=lst) >>> ser a 7 a 2 a 8 b 4 b 3 b 3 dtype: int64 >>> ser.groupby(level=0).std() a 3.21455 b 0.57735 dtype: float64 For DataFrameGroupBy: >>> data = {"a": [1, 3, 5, 7, 7, 8, 3], "b": [1, 4, 8, 4, 4, 2, 1]} >>> df = pd.DataFrame( ... data, index=["dog", "dog", "dog", "mouse", "mouse", "mouse", "mouse"] ... ) >>> df a b dog 1 1 dog 3 4 dog 5 8 mouse 7 4 mouse 7 4 mouse 8 2 mouse 3 1 >>> df.groupby(level=0).std() a b dog 2.000000 3.511885 mouse 2.217356 1.500000 r grouped_varr ddofrrc@t|djSNFr1)rr)rQrrrrs rjrzGroupBy.std..fQU377T&7Qrlrrrr) rTrrrsqrtror<rrrhrrrjrrrs ` ` rjrz GroupBy.stdsvF 6 " >77''00! !! (  ++Q) , rlct|r+ddlm}|j|tj |dS|j dfd|S)a# Compute variance of groups, excluding missing values. For multiple groupings, the result index will be a MultiIndex. Parameters ---------- ddof : int, default 1 Degrees of freedom. engine : str, default None * ``'cython'`` : Runs the operation through C-extensions from cython. * ``'numba'`` : Runs the operation through JIT compiled code from numba. * ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba`` engine_kwargs : dict, default None * For ``'cython'`` engine, there are no accepted ``engine_kwargs`` * For ``'numba'`` engine, the engine can accept ``nogil`` and ``parallel`` dictionary keys. The values must either be ``True`` or ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is ``{'nogil': False, 'parallel': False}`` numeric_only : bool, default False Include only `float`, `int` or `boolean` data. .. versionchanged:: 2.0.0 numeric_only now defaults to ``False``. skipna : bool, default True Exclude NA/null values. If an entire group is NA, the result will be NA. .. versionadded:: 3.0.0 Returns ------- Series or DataFrame Variance of values within each group. See Also -------- Series.var : Apply function var to a Series. DataFrame.var : Apply function var to each row or column of a DataFrame. Examples -------- For SeriesGroupBy: >>> lst = ["a", "a", "a", "b", "b", "b"] >>> ser = pd.Series([7, 2, 8, 4, 3, 3], index=lst) >>> ser a 7 a 2 a 8 b 4 b 3 b 3 dtype: int64 >>> ser.groupby(level=0).var() a 10.333333 b 0.333333 dtype: float64 For DataFrameGroupBy: >>> data = {"a": [1, 3, 5, 7, 7, 8, 3], "b": [1, 4, 8, 4, 4, 2, 1]} >>> df = pd.DataFrame( ... data, index=["dog", "dog", "dog", "mouse", "mouse", "mouse", "mouse"] ... ) >>> df a b dog 1 1 dog 3 4 dog 5 8 mouse 7 4 mouse 7 4 mouse 8 2 mouse 3 1 >>> df.groupby(level=0).var() a b dog 4.000000 12.333333 mouse 4.916667 2.250000 rrrvarc@t|djSr)rQr&r s rjrzGroupBy.var..n r!rlr")rTrrror<rrr$s ` ` rjr&z GroupBy.var sjz 6 " >**,, + ++Q) , rlc |rdnd}|j}|j|jjDchc]}|js|j c}t trj } | vrgng} nytj} |@t| tz} | rtd| d | z } | rtd| d|  fdtjD} t|jj}| D].}t||dd|\}}}|t|jz }0|j|d|j|j }t#d |j%}||_|r|j'|d }|j(r|j*j,}t/t1||j*_t/t1|jj}|j3|d }||j*_|rtt/t1|jj|j*j4}|j|j*j7||j(|j dj9d}||z}|j;d}|j<r|}n|j*}t?j@|j,}||vrtd|d||_|jCt/t1||_|jE}|jjdjjjF}tI||jKt1||}||_ |}|jM|jdScc}w)z Shared implementation of value_counts for SeriesGroupBy and DataFrameGroupBy. SeriesGroupBy additionally supports a bins argument. See the docstring of DataFrameGroupBy.value_counts for a description of arguments. proportionrzKeys z0 in subset cannot be in the groupby column keys.z) in subset do not exist in the DataFrame.c3ZK|]"\}}|vr|vrjdd|f$ywrf)r)ridx_name in_axis_namesr subsetteds rjrz(GroupBy._value_counts.. s;C -%92DC s(+F)rprrr)rrrrQstable)rr)rsort_remaining)rrrsumrzColumn label 'z' is duplicate of result columnrr value_countsr)'rrrr?in_axisrrrQsetr:rrBrrJrirrrsize sort_valuesrrrrangerr5r; droplevel transformfillnarrfill_missing_names set_names reset_indexrrMr@r%)!rhsubset normalizerrrrrlgroupingr,r unique_colsclashing doesnt_existr?rprr.gb result_seriesr index_levelrindexed_group_sizerrr: result_frame orig_dtypecolsr-rr.s! @@@rj _value_countszGroupBy._value_countst s )|g XX''+/--*A*A &XEUEUHMM  c6 "HHE+0M+ARuDckk*K!K $s='99$z*33 );6 $ ~-VW( #,CKK"8D001  1C' MGQ g//0 0I 1ZZ ]];;   Xrwwy1 !  )55#(6M 99!''--E(-c%j(9M   %DMM$;$; <=K)44!%5M).M   % c$--112M4G4G4O4OPF"/!6!6##--f5YY{{ "7" i  / /M*005M =="F"''E,,U[[9Gw >$7V!WXX!%M "'//%G 2E"FM (446L00377??EEJ 3::3w<ND#'L !F""488N"CCO s O< O<c"|rr|jjdk(rYt|jjs:t t |j d|d|jj|jdfd|S)ar Compute standard error of the mean of groups, excluding missing values. For multiple groupings, the result index will be a MultiIndex. Parameters ---------- ddof : int, default 1 Degrees of freedom. numeric_only : bool, default False Include only `float`, `int` or `boolean` data. .. versionchanged:: 2.0.0 numeric_only now defaults to ``False``. skipna : bool, default True Exclude NA/null values. If an entire group is NA, the result will be NA. .. versionadded:: 3.0.0 Returns ------- Series or DataFrame Standard error of the mean of values within each group. See Also -------- DataFrame.sem : Return unbiased standard error of the mean over requested axis. Series.sem : Return unbiased standard error of the mean over requested axis. Examples -------- For SeriesGroupBy: >>> lst = ["a", "a", "b", "b"] >>> ser = pd.Series([5, 10, 8, 14], index=lst) >>> ser a 5 a 10 b 8 b 14 dtype: int64 >>> ser.groupby(level=0).sem() a 2.5 b 3.0 dtype: float64 For DataFrameGroupBy: >>> data = [[1, 12, 11], [1, 15, 2], [2, 5, 8], [2, 6, 12]] >>> df = pd.DataFrame( ... data, ... columns=["a", "b", "c"], ... index=["tuna", "salmon", "catfish", "goldfish"], ... ) >>> df a b c tuna 1 12 11 salmon 1 15 2 catfish 2 5 8 goldfish 2 6 12 >>> df.groupby("a").sem() b c a 1 1.5 4.5 2 0.5 2.0 For Resampler: >>> ser = pd.Series( ... [1, 3, 2, 4, 3, 8], ... index=pd.DatetimeIndex( ... [ ... "2023-01-01", ... "2023-01-10", ... "2023-01-15", ... "2023-02-01", ... "2023-02-10", ... "2023-02-15", ... ] ... ), ... ) >>> ser.resample("MS").sem() 2023-01-01 0.577350 2023-02-01 1.527525 Freq: MS, dtype: float64 rz.sem called with numeric_only=z and dtype rc@t|djSr)rQrr s rjrzGroupBy.sem..U s&/33f3Mrlr")rr$r2rrrrtr)rhrrrs ` `rjrz GroupBy.sem sz DHHMMQ.7G7W:&&'( ,~[8HJ '' M% (  rlc|jj}d}t|jtrt|jj t rgt|jj tr@|jj jjtjurd}n,d}n)d}n&t|jj trd}t|jtr(|j||jj}n|j|}||j|}|j s|j#dj%}|S)ai Compute group sizes. Returns the number of rows in each group. This is useful for understanding the distribution of data across groups. Returns ------- DataFrame or Series Number of rows in each group as a Series if as_index is True or a DataFrame if as_index is False. See Also -------- Series.size : Apply function size to a Series. DataFrame.size : Apply function size to each row or column of a DataFrame. Examples -------- For SeriesGroupBy: >>> lst = ["a", "a", "b"] >>> ser = pd.Series([1, 2, 3], index=lst) >>> ser a 1 a 2 b 3 dtype: int64 >>> ser.groupby(level=0).size() a 2 b 1 dtype: int64 >>> data = [[1, 2, 3], [1, 5, 6], [7, 8, 9]] >>> df = pd.DataFrame( ... data, columns=["a", "b", "c"], index=["owl", "toucan", "eagle"] ... ) >>> df a b c owl 1 2 3 toucan 1 5 6 eagle 7 8 9 >>> df.groupby("a").size() a 1 2 7 1 dtype: int64 For Resampler: >>> ser = pd.Series( ... [1, 2, 3], ... index=pd.DatetimeIndex(["2023-01-01", "2023-01-15", "2023-02-01"]), ... ) >>> ser 2023-01-01 1 2023-01-15 2 2023-02-01 3 dtype: int64 >>> ser.resample("MS").size() 2023-01-01 2 2023-02-01 1 Freq: MS, dtype: int64 Nnumpy_nullablepyarrow)r) dtype_backendr5)rr5rrrQrr=rBrna_valuerrr>rrconvert_dtypesrrenamer=)rhrrQs rjr5z GroupBy.size[ sF##%EI dhh '$((..*=>dhhnn.>?xx~~++44>(, (8 $-MDHHNNO< 0  dhh '--f488==-IF--f5F  $***GF}}]]6*668F rlct|r*ddlm}|j|tj ||Sdfd }|j d|||S)a4 Compute sum of group values. Computes the sum for each group. Null values are excluded by default unless ``skipna`` is set to ``False``. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. .. versionchanged:: 2.0.0 numeric_only no longer accepts ``None``. min_count : int, default 0 The required number of valid values to perform the operation. If fewer than ``min_count`` non-NA values are present the result will be NA. skipna : bool, default True Exclude NA/null values. If the entire group is NA and ``skipna`` is ``True``, the result will be NA. .. versionchanged:: 3.0.0 engine : str, default None None * ``'cython'`` : Runs rolling apply through C-extensions from cython. * ``'numba'`` : Runs rolling apply through JIT compiled code from numba. Only available when ``raw`` is set to ``True``. * ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba`` engine_kwargs : dict, default None None * For ``'cython'`` engine, there are no accepted ``engine_kwargs`` * For ``'numba'`` engine, the engine can accept ``nogil`` and ``parallel`` dictionary keys. The values must either be ``True`` or ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is ``{'nogil': False, 'parallel': False}`` and will be applied to both the ``func`` and the ``apply`` groupby aggregation. Returns ------- Series or DataFrame Computed sum of values within each group. See Also -------- Series.sum : Return the sum of the values over the requested axis. DataFrame.sum : Return the sum of the values over the requested axis. Examples -------- For SeriesGroupBy: >>> lst = ["a", "a", "b", "b"] >>> ser = pd.Series([1, 2, 3, 4], index=lst) >>> ser a 1 a 2 b 3 b 4 dtype: int64 >>> ser.groupby(level=0).sum() a 3 b 7 dtype: int64 For DataFrameGroupBy: >>> data = [[1, 8, 2], [1, 2, 5], [2, 5, 8], [2, 6, 9]] >>> df = pd.DataFrame( ... data, ... columns=["a", "b", "c"], ... index=["tiger", "leopard", "cheetah", "lion"], ... ) >>> df a b c tiger 1 8 2 leopard 1 2 5 cheetah 2 5 8 lion 2 6 9 >>> df.groupby("a").sum() b c a 1 10 7 2 11 17 r) grouped_sumr c(|jSNr)r1rrs rj sum_compatzGroupBy.sum..sum_compat& wwfw--rlr1rrrrrr)rTrrVror<default_dtype_mappingr)rhrrrrrjrVrZs ` rjr1z GroupBy.sum sl@ 6 " >**..% +  .++)# , rlc<dfd }|jd|||S)a Compute prod of group values. This method computes the product of all values within each group, returning a result for each group. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. .. versionchanged:: 2.0.0 numeric_only no longer accepts ``None``. min_count : int, default 0 The required number of valid values to perform the operation. If fewer than ``min_count`` non-NA values are present the result will be NA. skipna : bool, default True Exclude NA/null values. If an entire group is NA, the result will be NA. .. versionadded:: 3.0.0 Returns ------- Series or DataFrame Computed prod of values within each group. See Also -------- Series.prod : Return the product of the values over the requested axis. DataFrame.prod : Return the product of the values over the requested axis. Examples -------- For SeriesGroupBy: >>> lst = ["a", "a", "b", "b"] >>> ser = pd.Series([1, 2, 3, 4], index=lst) >>> ser a 1 a 2 b 3 b 4 dtype: int64 >>> ser.groupby(level=0).prod() a 2 b 12 dtype: int64 For DataFrameGroupBy: >>> data = [[1, 8, 2], [1, 2, 5], [2, 5, 8], [2, 6, 9]] >>> df = pd.DataFrame( ... data, ... columns=["a", "b", "c"], ... index=["tiger", "leopard", "cheetah", "lion"], ... ) >>> df a b c tiger 1 8 2 leopard 1 2 5 cheetah 2 5 8 lion 2 6 9 >>> df.groupby("a").prod() b c a 1 16 10 2 30 72 c(|jSrX)prodrYs rj prod_compatz!GroupBy.prod..prod_compat~ s8868* *rlrar\r]r)rhrrrrbs ` rjraz GroupBy.prod2 s2X +'' % (  rlct|r+ddlm}|j|tj ||dSdfd }|j d|||S) ag Compute min of group values. Returns the minimum value for each group. Missing values are excluded by default but this behavior can be controlled with the ``skipna`` parameter. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. .. versionchanged:: 2.0.0 numeric_only no longer accepts ``None``. min_count : int, default -1 The required number of valid values to perform the operation. If fewer than ``min_count`` non-NA values are present the result will be NA. skipna : bool, default True Exclude NA/null values. If the entire group is NA and ``skipna`` is ``True``, the result will be NA. .. versionchanged:: 3.0.0 engine : str, default None None * ``'cython'`` : Runs rolling apply through C-extensions from cython. * ``'numba'`` : Runs rolling apply through JIT compiled code from numba. Only available when ``raw`` is set to ``True``. * ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba`` engine_kwargs : dict, default None None * For ``'cython'`` engine, there are no accepted ``engine_kwargs`` * For ``'numba'`` engine, the engine can accept ``nogil`` and ``parallel`` dictionary keys. The values must either be ``True`` or ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is ``{'nogil': False, 'parallel': False}`` and will be applied to both the ``func`` and the ``apply`` groupby aggregation. Returns ------- Series or DataFrame Computed min of values within each group. See Also -------- Series.min : Return the minimum of the values over the requested axis. DataFrame.min : Return the minimum of the values over the requested axis. Examples -------- For SeriesGroupBy: >>> lst = ["a", "a", "b", "b"] >>> ser = pd.Series([1, 2, 3, 4], index=lst) >>> ser a 1 a 2 b 3 b 4 dtype: int64 >>> ser.groupby(level=0).min() a 1 b 3 dtype: int64 For DataFrameGroupBy: >>> data = [[1, 8, 2], [1, 2, 5], [2, 5, 8], [2, 6, 9]] >>> df = pd.DataFrame( ... data, ... columns=["a", "b", "c"], ... index=["tiger", "leopard", "cheetah", "lion"], ... ) >>> df a b c tiger 1 8 2 leopard 1 2 5 cheetah 2 5 8 lion 2 6 9 >>> df.groupby("a").min() b c a 1 2 2 2 5 8 rgrouped_min_maxFr is_maxrc(|jSrX)rrYs rj min_compatzGroupBy.min..min_compat swwfw--rlrr\r]rTrreror<identity_dtype_mappingr)rhrrrrrjreris ` rjrz GroupBy.min soB 6 " B**//% +  . ++)# , rlct|r+ddlm}|j|tj ||dSdfd }|j d|||S) ag Compute max of group values. Returns the maximum value for each group. Missing values are excluded by default but this behavior can be controlled with the ``skipna`` parameter. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. .. versionchanged:: 2.0.0 numeric_only no longer accepts ``None``. min_count : int, default -1 The required number of valid values to perform the operation. If fewer than ``min_count`` non-NA values are present the result will be NA. skipna : bool, default True Exclude NA/null values. If the entire group is NA and ``skipna`` is ``True``, the result will be NA. .. versionchanged:: 3.0.0 engine : str, default None None * ``'cython'`` : Runs rolling apply through C-extensions from cython. * ``'numba'`` : Runs rolling apply through JIT compiled code from numba. Only available when ``raw`` is set to ``True``. * ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba`` engine_kwargs : dict, default None None * For ``'cython'`` engine, there are no accepted ``engine_kwargs`` * For ``'numba'`` engine, the engine can accept ``nogil`` and ``parallel`` dictionary keys. The values must either be ``True`` or ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is ``{'nogil': False, 'parallel': False}`` and will be applied to both the ``func`` and the ``apply`` groupby aggregation. Returns ------- Series or DataFrame Computed max of values within each group. See Also -------- Series.max : Return the maximum of the values over the requested axis. DataFrame.max : Return the maximum of the values over the requested axis. Examples -------- For SeriesGroupBy: >>> lst = ["a", "a", "b", "b"] >>> ser = pd.Series([1, 2, 3, 4], index=lst) >>> ser a 1 a 2 b 3 b 4 dtype: int64 >>> ser.groupby(level=0).max() a 2 b 4 dtype: int64 For DataFrameGroupBy: >>> data = [[1, 8, 2], [1, 2, 5], [2, 5, 8], [2, 6, 9]] >>> df = pd.DataFrame( ... data, ... columns=["a", "b", "c"], ... index=["tiger", "leopard", "cheetah", "lion"], ... ) >>> df a b c tiger 1 8 2 leopard 1 2 5 cheetah 2 5 8 lion 2 6 9 >>> df.groupby("a").max() b c a 1 8 5 2 6 9 rrdTrfc(|jSrX)rrYs rj max_compatzGroupBy.max..max_compatt r[rlrr\r]rj)rhrrrrrjrerns ` rjrz GroupBy.max soB 6 " B**//% +  .++)# , rlc6dd}|jd||||S)u Compute the first entry of each column within each group. NA values are skipped by default, so the result is the first non-NA value per column — which may differ from the first row of the group. Pass ``skipna=False`` to keep NAs. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. min_count : int, default -1 The required number of valid values to perform the operation. If fewer than ``min_count`` valid values are present the result will be NA. skipna : bool, default True Exclude NA values. If an entire group is NA, the result will be NA. .. versionadded:: 2.2.1 Returns ------- Series or DataFrame First values within each group. See Also -------- DataFrame.groupby : Apply a function groupby to each row or column of a DataFrame. api.typing.DataFrameGroupBy.last : Compute the last entry of each column within each group. api.typing.DataFrameGroupBy.nth : Take the nth row from each group. Examples -------- >>> df = pd.DataFrame( ... dict( ... A=[1, 1, 3], ... B=[None, 5, 6], ... C=[1, 2, 3], ... D=["3/11/2000", "3/12/2000", "3/13/2000"], ... ) ... ) >>> df["D"] = pd.to_datetime(df["D"]) >>> df.groupby("A").first() B C D A 1 5.0 1 2000-03-11 3 6.0 3 2000-03-13 >>> df.groupby("A").first(min_count=2) B C D A 1 NaN 1.0 2000-03-11 3 NaN NaN NaT >>> df.groupby("A").first(numeric_only=True) B C A 1 5.0 1 3 6.0 3 cdd}t|tr|j|St|tr||St t |)Nc|jt|j}t|s |jjjS|dS)z-Helper function for first item that isn't NA.rrr9rrrRrarrs rjfirstz2GroupBy.first..first_compat..first s<ggeAGGn-3x77==1111v rlrrQrrErfrQrr)rrus rj first_compatz#GroupBy.first..first_compat sE #y)yy''C(Sz!S **rlrur\r]r)rhrrrrxs rjruz GroupBy.first s1@ +'' % (  rlc6dd}|jd||||S)u Compute the last entry of each column within each group. NA values are skipped by default, so the result is the last non-NA value per column — which may differ from the last row of the group. Pass ``skipna=False`` to keep NAs. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. If None, will attempt to use everything, then use only numeric data. min_count : int, default -1 The required number of valid values to perform the operation. If fewer than ``min_count`` valid values are present the result will be NA. skipna : bool, default True Exclude NA values. If an entire group is NA, the result will be NA. .. versionadded:: 2.2.1 Returns ------- Series or DataFrame Last values within each group. See Also -------- DataFrame.groupby : Apply a function groupby to each row or column of a DataFrame. api.typing.DataFrameGroupBy.first : Compute the first entry of each column within each group. api.typing.DataFrameGroupBy.nth : Take the nth row from each group. Examples -------- >>> df = pd.DataFrame(dict(A=[1, 1, 3], B=[5, None, 6], C=[1, 2, 3])) >>> df.groupby("A").last() B C A 1 5.0 2 3 6.0 3 cdd}t|tr|j|St|tr||St t |)Nc|jt|j}t|s |jjjS|dS)z,Helper function for last item that isn't NA.rrrrss rjlastz/GroupBy.last..last_compat..last s<ggeAGGn-3x77==1112wrlrvrw)rr|s rj last_compatz!GroupBy.last..last_compat sD #y)yy&C(Cy S **rlr|r\r]r)rhrrrr}s rjr|z GroupBy.last s1^ +'' % (  rlc|jjdk(r|j}t|j}|s t d|j j|jddd}gd}|jj||j j|}|js|j}|S|jd }|S) aX Compute open, high, low and close values of a group, excluding missing values. For multiple groupings, the result index will be a MultiIndex Returns ------- DataFrame Open, high, low and close values within each group. See Also -------- DataFrame.agg : Aggregate using one or more operations over the specified axis. DataFrame.resample : Resample time-series data. DataFrame.groupby : Group DataFrame using a mapper or by a Series of columns. Examples -------- For SeriesGroupBy: >>> lst = [ ... "SPX", ... "CAC", ... "SPX", ... "CAC", ... "SPX", ... "CAC", ... "SPX", ... "CAC", ... ] >>> ser = pd.Series([3.4, 9.0, 7.2, 5.2, 8.8, 9.4, 0.1, 0.5], index=lst) >>> ser SPX 3.4 CAC 9.0 SPX 7.2 CAC 5.2 SPX 8.8 CAC 9.4 SPX 0.1 CAC 0.5 dtype: float64 >>> ser.groupby(level=0).ohlc() open high low close CAC 9.0 9.4 0.5 0.5 SPX 3.4 8.8 0.1 0.1 For DataFrameGroupBy: >>> data = { ... 2022: [1.2, 2.3, 8.9, 4.5, 4.4, 3, 2, 1], ... 2023: [3.4, 9.0, 7.2, 5.2, 8.8, 9.4, 8.2, 1.0], ... } >>> df = pd.DataFrame( ... data, index=["SPX", "CAC", "SPX", "CAC", "SPX", "CAC", "SPX", "CAC"] ... ) >>> df 2022 2023 SPX 1.2 3.4 CAC 2.3 9.0 SPX 8.9 7.2 CAC 4.5 5.2 SPX 4.4 8.8 CAC 3.0 9.4 SPX 2.0 8.2 CAC 1.0 1.0 >>> df.groupby(level=0).ohlc() 2022 2023 open high low close open high low close CAC 2.3 4.5 1.0 1.0 9.0 9.4 1.0 1.0 SPX 1.2 8.9 1.2 2.0 3.4 8.8 3.4 8.2 For Resampler: >>> ser = pd.Series( ... [1, 3, 2, 4, 3, 5], ... index=pd.DatetimeIndex( ... [ ... "2023-01-01", ... "2023-01-10", ... "2023-01-15", ... "2023-02-01", ... "2023-02-10", ... "2023-02-15", ... ] ... ), ... ) >>> ser.resample("MS").ohlc() open high low close 2023-01-01 1 3 1 2 2023-02-01 4 5 3 5 rzNo numeric types to aggregateohlcrrr)openhighlowclose)rr:c"|jSrf)r)sgbs rjrzGroupBy.ohlc.. s CHHJrl)rr$rr2rr&rrr _constructor_expanddimrrr=_apply_to_column_groupbys)rhr is_numericr agg_namesrs rjrz GroupBy.ohlc s| 88==A $$C)#))4J ?@@88 V!r9J9IXX44$--"<". s!** +Wg%rlr)rrrr$unstackr>r[rrrr rrIrOr)rhrrrr describedrs ``` rjrzGroupBy.describe s '' s8q= ''%Ixx1}""**,??$&&++BQ/ /   dJ 5 //!% 0F !}}008F(V5FL   s C<<Dc  Lddlm} | r td| ||f|||||||d| S)a Provide resampling within each group of a groupby. Given a grouper, the function resamples it according to a string "string" -> "frequency". See the :ref:`frequency aliases ` documentation for more details. Parameters ---------- rule : str or DateOffset The offset string or object representing target grouper conversion. closed : {'right', 'left'}, optional Which side of bin interval is closed. See :meth:`Series.resample`. label : {'right', 'left'}, optional Which bin edge label to label bucket with. See :meth:`Series.resample`. convention : {'start', 'end', 's', 'e'}, optional For ``PeriodIndex`` only. See :meth:`Series.resample`. on : str, optional For a DataFrame, column to use instead of index for resampling. Column must be datetime-like. origin : Timestamp or str, default 'start_day' The timestamp on which to adjust the grouping. See :meth:`Series.resample` for accepted string values. offset : Timedelta or str, optional An offset timedelta added to the origin. group_keys : bool, default False Whether to include the group keys in the result index when using ``.apply()`` on the resampled object. include_groups : bool, default False When True, will attempt to include the groupings in the operation in the case that they are columns of the DataFrame. If this raises a TypeError, the result will be computed with the groupings excluded. When False, the groupings will be excluded when applying ``func``. .. versionadded:: 2.2.0 .. versionchanged:: 3.0 The default was changed to False, and True is no longer allowed. **kwargs Additional keyword arguments forwarded to the underlying :class:`Grouper`. Returns ------- DatetimeIndexResampler, PeriodIndexResampler or TimedeltaResampler Resampler object for the type of the index. See Also -------- Series.resample : Resample a Series. DataFrame.resample : Resample a DataFrame. Grouper : Specify a frequency to resample with when grouping by a key. DatetimeIndex.resample : Frequency conversion and resampling of time series. Examples -------- >>> idx = pd.date_range("1/1/2000", periods=4, freq="min") >>> df = pd.DataFrame(data=4 * [range(2)], index=idx, columns=["a", "b"]) >>> df.iloc[2, 0] = 5 >>> df a b 2000-01-01 00:00:00 0 1 2000-01-01 00:01:00 0 1 2000-01-01 00:02:00 5 1 2000-01-01 00:03:00 0 1 Downsample the DataFrame into 3 minute bins and sum the values of the timestamps falling into a bin. >>> df.groupby("a").resample("3min").sum() b a 0 2000-01-01 00:00:00 2 2000-01-01 00:03:00 1 5 2000-01-01 00:00:00 1 Upsample the series into 30 second bins. >>> df.groupby("a").resample("30s").sum() b a 0 2000-01-01 00:00:00 1 2000-01-01 00:00:30 0 2000-01-01 00:01:00 1 2000-01-01 00:01:30 0 2000-01-01 00:02:00 0 2000-01-01 00:02:30 0 2000-01-01 00:03:00 1 5 2000-01-01 00:02:00 1 Resample by month. Values are assigned to the month of the period. >>> df.groupby("a").resample("ME").sum() b a 0 2000-01-31 3 5 2000-01-31 1 Downsample the series into 3 minute bins as above, but close the right side of the bin interval. >>> (df.groupby("a").resample("3min", closed="right").sum()) b a 0 1999-12-31 23:57:00 1 2000-01-01 00:00:00 2 5 2000-01-01 00:00:00 1 Downsample the series into 3 minute bins and close the right side of the bin interval, but label each bin using the right edge instead of the left. >>> (df.groupby("a").resample("3min", closed="right", label="right").sum()) b a 0 2000-01-01 00:00:00 1 2000-01-01 00:03:00 2 5 2000-01-01 00:03:00 1 r)get_resampler_for_groupingr)onclosedr| conventionoriginoffsetr)pandas.core.resamplerr) rhrulerr|rrrrrrrrrs rjresamplezGroupBy.resample sQX D HI I)    !!    rlc nddlm}||j||||||||j|j S)a Return a rolling grouper, providing rolling functionality per group. Allows the application of rolling window operations (e.g., moving averages) independently within each group defined by the groupby keys. Parameters ---------- window : int, timedelta, str, offset, or BaseIndexer subclass Interval of the moving window. If an integer, the delta between the start and end of each window. The number of points in the window depends on the ``closed`` argument. If a timedelta, str, or offset, the time period of each window. Each window will be a variable sized based on the observations included in the time-period. This is only valid for datetimelike indexes. The offset must correspond to a fixed frequency (for example, ``'2D'`` or ``'1h'``); non-fixed frequencies such as ``'B'`` (business day) or ``'ME'`` (month end) are not supported and raise ``ValueError``. To learn more about the offsets & frequency strings, please see :ref:`this link`. If a BaseIndexer subclass, the window boundaries based on the defined ``get_window_bounds`` method. Additional rolling keyword arguments, namely ``min_periods``, ``center``, ``closed`` and ``step`` will be passed to ``get_window_bounds``. min_periods : int, default None Minimum number of observations in window required to have a value; otherwise, result is ``np.nan``. For a window that is specified by an offset, ``min_periods`` will default to 1. For a window that is specified by an integer, ``min_periods`` will default to the size of the window. center : bool, default False If False, set the window labels as the right edge of the window index. If True, set the window labels as the center of the window index. win_type : str, default None If ``None``, all points are evenly weighted. If a string, it must be a valid `scipy.signal window function `__. Certain Scipy window types require additional parameters to be passed in the aggregation function. The additional parameters must match the keywords specified in the Scipy window type method signature. on : str, optional For a DataFrame, a column label or Index level on which to calculate the rolling window, rather than the DataFrame's index. For integer ``window`` values, the window bounds are based on the number of observations and are not calculated using the values of the ``on`` column. The ``on`` column is excluded from the aggregation, but is included in the result when its values differ from the object's index. closed : str, default None Determines the inclusivity of points in the window If ``'right'``, uses the window (first, last] meaning the last point is included in the calculations. If ``'left'``, uses the window [first, last) meaning the first point is included in the calculations. If ``'both'``, uses the window [first, last] meaning all points in the window are included in the calculations. If ``'neither'``, uses the window (first, last) meaning the first and last points in the window are excluded from calculations. () and [] are referencing open and closed set notation respetively. Default ``None`` (``'right'``). method : str {'single', 'table'}, default 'single' Execute the rolling operation per single column or row (``'single'``) or over the entire object (``'table'``). This argument is only implemented when specifying ``engine='numba'`` in the method call. Returns ------- pandas.api.typing.RollingGroupBy Return a new grouper with our rolling appended. See Also -------- Series.rolling : Calling object with Series data. DataFrame.rolling : Calling object with DataFrames. Series.groupby : Apply a function groupby to a Series. DataFrame.groupby : Apply a function groupby. Examples -------- >>> df = pd.DataFrame( ... { ... "A": [1, 1, 2, 2], ... "B": [1, 2, 3, 4], ... "C": [0.362, 0.227, 1.267, -0.562], ... } ... ) >>> df A B C 0 1 1 0.362 1 1 2 0.227 2 2 3 1.267 3 2 4 -0.562 >>> df.groupby("A").rolling(2).sum() B C A 1 0 NaN NaN 1 3.0 0.589 2 2 NaN NaN 3 7.0 0.705 >>> df.groupby("A").rolling(2, min_periods=1).sum() B C A 1 0 1.0 0.362 1 3.0 0.589 2 2 3.0 1.267 3 7.0 0.705 >>> df.groupby("A").rolling(2, on="B").sum() B C A 1 0 1 NaN 1 2 0.589 2 2 3 NaN 3 4 0.705 r)rb) windowr centerwin_typerrrr _as_index)pandas.core.windowrbrrr) rhrr rrrrrrbs rjrollingzGroupBy.rollingRsAt 6   #]]mm  rlcNddlm}||j|||jS)a  Return an expanding grouper, providing expanding functionality per group. Each group's expanding window includes all prior rows within that group up to and including the current row. Parameters ---------- min_periods : int, default 1 Minimum number of observations in window required to have a value; otherwise, result is ``np.nan``. method : str {'single', 'table'}, default 'single' Execute the expanding operation per single column or row (``'single'``) or over the entire object (``'table'``). This argument is only implemented when specifying ``engine='numba'`` in the method call. Returns ------- pandas.api.typing.ExpandingGroupBy An object that supports expanding transformations over each group. See Also -------- Series.expanding : Expanding transformations for Series. DataFrame.expanding : Expanding transformations for DataFrames. Series.groupby : Apply a function groupby to a Series. DataFrame.groupby : Apply a function groupby. Examples -------- >>> df = pd.DataFrame( ... { ... "Class": ["A", "A", "A", "B", "B", "B"], ... "Value": [10, 20, 30, 40, 50, 60], ... } ... ) >>> df Class Value 0 A 10 1 A 20 2 A 30 3 B 40 4 B 50 5 B 60 >>> df.groupby("Class").expanding().mean() Value Class A 0 10.0 1 15.0 2 20.0 B 3 40.0 4 45.0 5 50.0 r)r`)r rr)rr`rr)rhr rr`s rj expandingzGroupBy.expandings+@ 8   #]]   rlc \ddlm} | |j||||||||| |j S)a Return an ewm grouper, providing ewm functionality per group. The decay can be specified in terms of center of mass, span, half-life, or smoothing factor alpha. Parameters ---------- com : float, optional Specify decay in terms of center of mass. Alternative to ``span``, ``halflife``, and ``alpha``. span : float, optional Specify decay in terms of span. halflife : float, str, or Timedelta, optional Specify decay in terms of half-life. alpha : float, optional Specify smoothing factor directly. min_periods : int, default 0 Minimum number of observations in the window required to have a value; otherwise, result is ``np.nan``. adjust : bool, default True Divide by decaying adjustment factor to account for imbalance in relative weights. ignore_na : bool, default False Ignore missing values when calculating weights. times : str or array-like of datetime64, optional Times corresponding to the observations. method : {'single', 'table'}, default 'single' Execute the operation per group independently (``'single'``) or over the entire object before regrouping (``'table'``). Only applicable to ``mean()``, and only when using ``engine='numba'``. Returns ------- pandas.api.typing.ExponentialMovingWindowGroupBy An object that supports exponentially weighted moving transformations over each group. See Also -------- Series.ewm : EWM transformations for Series. DataFrame.ewm : EWM transformations for DataFrames. Series.groupby : Apply a function groupby to a Series. DataFrame.groupby : Apply a function groupby. Examples -------- >>> df = pd.DataFrame( ... { ... "Class": ["A", "A", "A", "B", "B", "B"], ... "Value": [10, 20, 30, 40, 50, 60], ... } ... ) >>> df Class Value 0 A 10 1 A 20 2 A 30 3 B 40 4 B 50 5 B 60 >>> df.groupby("Class").ewm(com=0.5).mean() Value Class A 0 10.000000 1 17.500000 2 26.153846 B 3 40.000000 4 47.500000 5 56.153846 r)ra) rspanhalflifealphar adjust ignore_natimesrr)rrarr) rhrrrrr rrrrras rjewmz GroupBy.ewmDsAz F-   #]]  rlcT |d}jj}jj}ttj |||dk(| d fd }j }|j|}j|}jj|_ |S)a Shared function for `pad` and `backfill` to call Cython method. Parameters ---------- direction : {'ffill', 'bfill'} Direction passed to underlying Cython function. `bfill` will cause values to be filled backwards. `ffill` and any other values will default to a forward fill limit : int, default None Maximum number of consecutive values to fill. If `None`, this method will convert to -1 prior to passing to Cython Returns ------- `Series` or `DataFrame` with filled values See Also -------- pad : Forward fill values within each group. backfill : Backward fill values within each group. rffill)r*limit compute_ffillrct|}|jdk(rOtj|jtj }||t j||St|tjrY|j}jjrt|j}tj|j|}n0t|j|j|j}t!|D]a\}}tj|jdtj }|||t j||||ddf<c|S)Nrr)rr+)r7r$rrrrr:rrndarrayrrr r+r_emptyrB) r&r+r-rri value_elementcol_funcrhs rjblk_funczGroupBy._fill..blk_funcs>> key = [0, 0, 1, 1] >>> ser = pd.Series([np.nan, 2, 3, np.nan], index=key) >>> ser 0 NaN 0 2.0 1 3.0 1 NaN dtype: float64 >>> ser.groupby(level=0).ffill() 0 NaN 0 2.0 1 3.0 1 3.0 dtype: float64 For DataFrameGroupBy: >>> df = pd.DataFrame( ... { ... "key": [0, 0, 1, 1, 1], ... "A": [np.nan, 2, np.nan, 3, np.nan], ... "B": [2, 3, np.nan, np.nan, np.nan], ... "C": [np.nan, np.nan, 2, np.nan, np.nan], ... } ... ) >>> df key A B C 0 0 NaN 2.0 NaN 1 0 2.0 3.0 NaN 2 1 NaN NaN 2.0 3 1 3.0 NaN NaN 4 1 NaN NaN NaN Propagate non-null values forward or backward within each group along columns. >>> df.groupby("key").ffill() A B C 0 NaN 2.0 NaN 1 2.0 3.0 NaN 2 NaN NaN 2.0 3 3.0 NaN 2.0 4 3.0 NaN 2.0 Propagate non-null values forward or backward within each group along rows. >>> df.T.groupby(np.array([0, 0, 1, 1])).ffill().T key A B C 0 0.0 0.0 2.0 2.0 1 0.0 2.0 3.0 3.0 2 1.0 1.0 NaN 2.0 3 1.0 3.0 NaN NaN 4 1.0 1.0 NaN NaN Only replace the first NaN element within a group along columns. >>> df.groupby("key").ffill(limit=1) A B C 0 NaN 2.0 NaN 1 2.0 3.0 NaN 2 NaN NaN 2.0 3 3.0 NaN 2.0 4 3.0 NaN NaN rrrrhrs rjrz GroupBy.ffillszzz'z//rlc(|jd|S)a- Backward fill the values. Fill missing values within each group by propagating the next valid observation backward. Parameters ---------- limit : int, optional Limit of how many values to fill. Returns ------- Series or DataFrame Object with missing values filled. See Also -------- Series.bfill : Backward fill the missing values in the dataset. DataFrame.bfill: Backward fill the missing values in the dataset. Series.fillna: Fill NaN values of a Series. DataFrame.fillna: Fill NaN values of a DataFrame. Examples -------- With Series: >>> index = ["Falcon", "Falcon", "Parrot", "Parrot", "Parrot"] >>> s = pd.Series([None, 1, None, None, 3], index=index) >>> s Falcon NaN Falcon 1.0 Parrot NaN Parrot NaN Parrot 3.0 dtype: float64 >>> s.groupby(level=0).bfill() Falcon 1.0 Falcon 1.0 Parrot 3.0 Parrot 3.0 Parrot 3.0 dtype: float64 >>> s.groupby(level=0).bfill(limit=1) Falcon 1.0 Falcon 1.0 Parrot NaN Parrot 3.0 Parrot 3.0 dtype: float64 With DataFrame: >>> df = pd.DataFrame( ... {"A": [1, None, None, None, 4], "B": [None, None, 5, None, 7]}, ... index=index, ... ) >>> df A B Falcon 1.0 NaN Falcon NaN NaN Parrot NaN 5.0 Parrot NaN NaN Parrot 4.0 7.0 >>> df.groupby(level=0).bfill() A B Falcon 1.0 NaN Falcon NaN NaN Parrot 4.0 5.0 Parrot 4.0 7.0 Parrot 4.0 7.0 >>> df.groupby(level=0).bfill(limit=1) A B Falcon 1.0 NaN Falcon NaN NaN Parrot NaN 5.0 Parrot 4.0 7.0 Parrot 4.0 7.0 bfillrrrs rjrz GroupBy.bfill\sdzz'z//rlct|S)a Take the nth row from each group if n is an int, otherwise a subset of rows. .. deprecated:: 3.1.0 Index notation (``g.nth[n]``) is deprecated in favor of calling ``g.nth(n)`` and will be removed in a future version of pandas. If dropna, will take the nth non-null row, dropna is either 'all' or 'any'; this is equivalent to calling dropna(how=dropna) before the groupby. Returns ------- Series or DataFrame N-th value within each group. See Also -------- Series.nth : Apply function nth to a Series. DataFrame.nth : Apply function nth to each row or column of a DataFrame. Examples -------- >>> df = pd.DataFrame( ... {"A": [1, 1, 2, 1, 2], "B": [np.nan, 2, 3, 4, 5]}, columns=["A", "B"] ... ) >>> g = df.groupby("A") >>> g.nth(0) A B 0 1 NaN 2 2 3.0 >>> g.nth(1) A B 1 1 2.0 4 2 5.0 >>> g.nth(-1) A B 3 1 4.0 4 2 5.0 >>> g.nth([0, 1]) A B 0 1 NaN 1 1 2.0 2 2 3.0 4 2 5.0 >>> g.nth(slice(None, -1)) A B 0 1 NaN 1 1 2.0 2 2 3.0 Specifying `dropna` allows ignoring ``NaN`` values >>> g.nth(0, dropna="any") A B 1 1 2.0 2 2 3.0 When the specified ``n`` is larger than any of the groups, an empty DataFrame is returned >>> g.nth(3, dropna="any") Empty DataFrame Columns: [A, B] Index: [] )rLrs rjnthz GroupBy.nthsN"$''rlc|sB|j|}|jj}||dk7z}|j|}|St |s t d|dvrt d|dt d|}|jj|d}t|t|jk(r |j}n|jj}|jj|j|j}|jjr.|dk(} tj | t"|} t%| d d }|j'||j(|j* } | j-|S) Nrz4dropna option only supported for an integer argumentrz_For a DataFrame or Series groupby.nth, dropna must be either None, 'any' or 'all', (was passed z).rr)rrInt64F)rr})rr)"_make_mask_from_positional_indexerrr_mask_selected_objr/rrrrrr codes_infoisinrr rrrrMrirrr) rhrrr+rrdroppedrrnullsr&grbs rj_nthz GroupBy._nthsd ::1=D--##C3"9%D))$/CJ!}ST T  '%hb*  N$$++Q+? w<3t112 2mmG ==%%Dmm..tyy/GHG}}++2 %W5gEBoog DIIoNwwqzrlc $ |j|d}|j|}|jj|}|j}t j |j|j\ t|r)tj|gtjd}n'tj|tj}|jj|jj|jrdk\t!t#t$j&  d fd } |j(j+| } |j| } |j-| |S) a Return group values at the given quantile, a la numpy.percentile. This method returns the value at the given quantile for each group, using the specified interpolation method when the desired quantile falls between two data points. Parameters ---------- q : float or array-like, default 0.5 (50% quantile) Value(s) between 0 and 1 providing the quantile(s) to compute. interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'} Method to use when the desired quantile falls between two points. numeric_only : bool, default False Include only `float`, `int` or `boolean` data. .. versionchanged:: 2.0.0 numeric_only now defaults to ``False``. Returns ------- Series or DataFrame Return type determined by caller of GroupBy object. See Also -------- Series.quantile : Similar method for Series. DataFrame.quantile : Similar method for DataFrame. numpy.percentile : NumPy method to compute qth percentile. Examples -------- >>> df = pd.DataFrame( ... [["a", 1], ["a", 2], ["a", 3], ["b", 1], ["b", 3], ["b", 5]], ... columns=["key", "val"], ... ) >>> df.groupby("key").quantile() val key a 2.0 b 3.0 quantilerrNr)r*rF interpolationr_r`c\t|tr|j St|jrt d|jdt |jr t dt|}t|jr#tjtjnd}tj|}d}|jdk(r|jd}tj| ftj}|jdk(r|d||dd n&t!|D]}||||||dd |jdk(r|j#d }n|j%| z}| d vr|j'|}|S) N)rFrrrr_r`zdtype 'z'' does not support operation 'quantile'z#Cannot use quantile with bool dtyperrcrrF)r&r+ result_maskis_datetimelikeK>linearmidpoint)rr?_groupby_quantiler3rrr-r7r0rrrr$rrrr7rvrr)r&r+ inferencevalsncolsrrr`rrrrnqsrFr_s rjrz"GroupBy.quantile..blk_funcs&.1//"/#! 0v||,fll^+RSV\\* EFFN>NO  Q<1#RZZ0B)-GARZZ0BGmm--'' ;;cQh-C"g  % %'  = = ~**++H5&&w/++CG+<>> df = pd.DataFrame({"color": ["red", None, "red", "blue", "blue", "red"]}) >>> df color 0 red 1 NaN 2 red 3 blue 4 blue 5 red >>> df.groupby("color").ngroup() 0 1.0 1 NaN 2 1.0 3 0.0 4 0.0 5 1.0 dtype: float64 >>> df.groupby("color", dropna=False).ngroup() 0 1 1 2 2 1 3 0 4 0 5 1 dtype: int64 >>> df.groupby("color", dropna=False).ngroup(ascending=False) 0 1 1 0 2 1 3 2 4 2 5 1 dtype: int64 rc34K|]}|jywrf_passed_categoricalrpings rjrz!GroupBy.ngroup..sLDt''Ldense) ties_methodrr)rrrrr rrrrrrr?rrr)rhrrrcomp_idsrrs rjngroupzGroupBy.ngroups~'' ==$$ == ' 'xxBAHJJEHHE LDMM4K4KL LxW=AH))(E)G\\A%.F rlcv|jj}|j|}|j||S)ae Number each item in each group from 0 to the length of that group - 1. Essentially this is equivalent to .. code-block:: python self.apply(lambda x: pd.Series(np.arange(len(x)), x.index)) Parameters ---------- ascending : bool, default True If False, number in reverse, from length of group - 1 to 0. Returns ------- Series Sequence number of each element within each group. See Also -------- .ngroup : Number the groups themselves. Examples -------- >>> df = pd.DataFrame([["a"], ["a"], ["a"], ["b"], ["b"], ["a"]], columns=["A"]) >>> df A 0 a 1 a 2 a 3 b 4 b 5 a >>> df.groupby("A").cumcount() 0 0 1 1 2 2 3 0 4 1 5 3 dtype: int64 >>> df.groupby("A").cumcount(ascending=False) 0 3 1 2 2 1 3 1 4 0 5 0 dtype: int64 )r)rrrr)rhrr cumcountss rjcumcountzGroupBy.cumcounts<j))//((9(= '' 599rlc\|dvr d}t|||||d}|j dddi|S)aC Provide the rank of values within each group. This method assigns ranks to values within each group, with options for handling duplicate values, NaN values, and computing percentage ranks. Parameters ---------- method : {'average', 'min', 'max', 'first', 'dense'}, default 'average' * average: average rank of group. * min: lowest rank in group. * max: highest rank in group. * first: ranks assigned in order they appear in the array. * dense: like 'min', but rank always increases by 1 between groups. ascending : bool, default True False for ranks by high (1) to low (N). na_option : {'keep', 'top', 'bottom'}, default 'keep' * keep: leave NA values where they are. * top: smallest rank if ascending. * bottom: smallest rank if descending. pct : bool, default False Compute percentage rank of data within each group. Returns ------- DataFrame The ranking of values within each group. See Also -------- Series.rank : Apply function rank to a Series. DataFrame.rank : Apply function rank to each row or column of a DataFrame. Examples -------- >>> df = pd.DataFrame( ... { ... "group": ["a", "a", "a", "a", "a", "b", "b", "b", "b", "b"], ... "value": [2, 4, 2, 3, 5, 1, 2, 4, 1, 5], ... } ... ) >>> df group value 0 a 2 1 a 4 2 a 2 3 a 3 4 a 5 5 b 1 6 b 2 7 b 4 8 b 1 9 b 5 >>> for method in ["average", "min", "max", "dense", "first"]: ... df[f"{method}_rank"] = df.groupby("group")["value"].rank(method) >>> df group value average_rank min_rank max_rank dense_rank first_rank 0 a 2 1.5 1.0 2.0 1.0 1.0 1 a 4 4.0 4.0 4.0 3.0 4.0 2 a 2 1.5 1.0 2.0 1.0 2.0 3 a 3 3.0 3.0 3.0 2.0 3.0 4 a 5 5.0 5.0 5.0 4.0 5.0 5 b 1 1.5 1.0 2.0 1.0 1.0 6 b 2 3.0 3.0 3.0 2.0 3.0 7 b 4 4.0 4.0 4.0 3.0 4.0 8 b 1 1.5 1.0 2.0 1.0 2.0 9 b 5 5.0 5.0 5.0 4.0 5.0 >topkeepbottomz3na_option must be one of 'keep', 'top', or 'bottom')rr na_optionpctrF)rank)rr)rhrrrrrrrs rjrz GroupBy.rankRs^X 5 5GCS/ !"""  &t%%     rlctjd||dg|s|r$tjdtt |j d||S)al Cumulative product for each group. Returns a Series or DataFrame of the same size with the cumulative product computed within each group. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. skipna : bool, default True Exclude NA/null values. If an entire row/column is NA, the result will be NA. *args : tuple Positional arguments to be passed to `func`. .. deprecated:: 3.1.0 Passing ``*args`` to GroupBy.cumprod is deprecated and will be removed in a future version of pandas. **kwargs : dict Additional keyword arguments to be passed to the function. .. deprecated:: 3.1.0 Passing ``**kwargs`` to GroupBy.cumprod is deprecated and will be removed in a future version of pandas. Returns ------- Series or DataFrame Cumulative product for each group. Same object type as the caller. See Also -------- Series.cumprod : Apply function cumprod to a Series. DataFrame.cumprod : Apply function cumprod to each row or column of a DataFrame. Examples -------- For SeriesGroupBy: >>> lst = ["a", "a", "b"] >>> ser = pd.Series([6, 2, 0], index=lst) >>> ser a 6 a 2 b 0 dtype: int64 >>> ser.groupby(level=0).cumprod() a 6 a 12 b 0 dtype: int64 For DataFrameGroupBy: >>> data = [[1, 8, 2], [1, 2, 5], [2, 6, 9]] >>> df = pd.DataFrame( ... data, columns=["a", "b", "c"], index=["cow", "horse", "bull"] ... ) >>> df a b c cow 1 8 2 horse 1 2 5 bull 2 6 9 >>> df.groupby("a").groups {1: ['cow', 'horse'], 2: ['bull']} >>> df.groupby("a").cumprod() b c cow 8 2 horse 16 10 bull 6 9 cumprodrzpPassing additional arguments to GroupBy.cumprod is deprecated and will be removed in a future version of pandas.rrnvvalidate_groupby_funcrrr'r)rrhrrrqrrs rjrzGroupBy.cumprodsUb   D&8*E 6 MME+-   %%if%MMrlctjd||dg|s|r$tjdtt |j d||S)al Cumulative sum for each group. Returns a Series or DataFrame of the same size with the cumulative sum computed within each group. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. skipna : bool, default True Exclude NA/null values. If an entire row/column is NA, the result will be NA. *args : tuple Positional arguments to be passed to `func`. .. deprecated:: 3.1.0 Passing ``*args`` to GroupBy.cumsum is deprecated and will be removed in a future version of pandas. **kwargs : dict Additional keyword arguments to be passed to the function. .. deprecated:: 3.1.0 Passing ``**kwargs`` to GroupBy.cumsum is deprecated and will be removed in a future version of pandas. Returns ------- Series or DataFrame Cumulative sum for each group. Same object type as the caller. See Also -------- Series.cumsum : Apply function cumsum to a Series. DataFrame.cumsum : Apply function cumsum to each row or column of a DataFrame. Examples -------- For SeriesGroupBy: >>> lst = ["a", "a", "b"] >>> ser = pd.Series([6, 2, 0], index=lst) >>> ser a 6 a 2 b 0 dtype: int64 >>> ser.groupby(level=0).cumsum() a 6 a 8 b 0 dtype: int64 For DataFrameGroupBy: >>> data = [[1, 8, 2], [1, 2, 5], [2, 6, 9]] >>> df = pd.DataFrame( ... data, columns=["a", "b", "c"], index=["fox", "gorilla", "lion"] ... ) >>> df a b c fox 1 8 2 gorilla 1 2 5 lion 2 6 9 >>> df.groupby("a").groups {1: ['fox', 'gorilla'], 2: ['lion']} >>> df.groupby("a").cumsum() b c fox 8 2 gorilla 10 7 lion 6 9 rrzoPassing additional arguments to GroupBy.cumsum is deprecated and will be removed in a future version of pandas.rrrrs rjrzGroupBy.cumsum sUb   4(D 6 MME+-   %%h V%LLrlc v|r$tjdtt|j d||S)a Cumulative min for each group. Returns a same-sized object where each value is replaced by the minimum of all preceding values in its group. Parameters ---------- numeric_only : bool, default False Include only `float`, `int` or `boolean` data. skipna : bool, default True Exclude NA/null values. If an entire row/column is NA, the result will be NA. **kwargs : dict, optional Additional keyword arguments to be passed to the function. .. deprecated:: 3.1.0 Passing ``**kwargs`` to GroupBy.cummin is deprecated and will be removed in a future version of pandas. Returns ------- Series or DataFrame Cumulative min for each group. Same object type as the caller. See Also -------- Series.cummin : Apply function cummin to a Series. DataFrame.cummin : Apply function cummin to each row or column of a DataFrame. Examples -------- For SeriesGroupBy: >>> lst = ["a", "a", "a", "b", "b", "b"] >>> ser = pd.Series([1, 6, 2, 3, 0, 4], index=lst) >>> ser a 1 a 6 a 2 b 3 b 0 b 4 dtype: int64 >>> ser.groupby(level=0).cummin() a 1 a 1 a 1 b 3 b 0 b 0 dtype: int64 For DataFrameGroupBy: >>> data = [[1, 0, 2], [1, 1, 5], [6, 6, 9]] >>> df = pd.DataFrame( ... data, columns=["a", "b", "c"], index=["snake", "rabbit", "turtle"] ... ) >>> df a b c snake 1 0 2 rabbit 1 1 5 turtle 6 6 9 >>> df.groupby("a").groups {1: ['snake', 'rabbit'], 6: ['turtle']} >>> df.groupby("a").cummin() b c snake 0 2 rabbit 0 2 turtle 6 9 zoPassing additional arguments to GroupBy.cummin is deprecated and will be removed in a future version of pandas.rcumminrrrr'r)rrhrrrrs rjrzGroupBy.cumminesD^  MME+-   %% <&  rlc v|r$tjdtt|j d||S)aW Cumulative max for each group. Returns the cumulative maximum of values within each group. The result has the same size as the input, with each element representing the maximum of all preceding elements (including itself) within its group. Parameters ---------- numeric_only : bool, default False Include only `float`, `int` or `boolean` data. skipna : bool, default True Exclude NA/null values. If an entire row/column is NA, the result will be NA. **kwargs : dict, optional Additional keyword arguments to be passed to the function. .. deprecated:: 3.1.0 Passing ``**kwargs`` to GroupBy.cummax is deprecated and will be removed in a future version of pandas. Returns ------- Series or DataFrame Cumulative max for each group. Same object type as the caller. See Also -------- Series.cummax : Apply function cummax to a Series. DataFrame.cummax : Apply function cummax to each row or column of a DataFrame. Examples -------- For SeriesGroupBy: >>> lst = ["a", "a", "a", "b", "b", "b"] >>> ser = pd.Series([1, 6, 2, 3, 1, 4], index=lst) >>> ser a 1 a 6 a 2 b 3 b 1 b 4 dtype: int64 >>> ser.groupby(level=0).cummax() a 1 a 6 a 6 b 3 b 3 b 4 dtype: int64 For DataFrameGroupBy: >>> data = [[1, 8, 2], [1, 1, 0], [2, 6, 9]] >>> df = pd.DataFrame( ... data, columns=["a", "b", "c"], index=["cow", "horse", "bull"] ... ) >>> df a b c cow 1 8 2 horse 1 1 0 bull 2 6 9 >>> df.groupby("a").groups {1: ['cow', 'horse'], 2: ['bull']} >>> df.groupby("a").cummax() b c cow 8 2 horse 8 2 bull 6 9 zoPassing additional arguments to GroupBy.cummax is deprecated and will be removed in a future version of pandas.rcummaxrrrs rjrzGroupBy.cummaxsD`  MME+-   %% <&  rlc t|r.td|}t|dk(r tdddlm}d}nBt |std|dt|d|r td td |g}d }g}|D]it stddtd&fd }|j||jd} ntjurd |jj} |jj} t!j"t| t j$} t'j(| | | |j*} | j-d| j.| fid} |rGt1| t2rtd| j5} | j7|r|dnd} |j9td| lt|dk(r|dS|dd S)a Shift each group by periods observations. If freq is passed, the index will be increased using the periods and the freq. Parameters ---------- periods : int | Sequence[int], default 1 Number of periods to shift. If a list of values, shift each group by each period. freq : str, optional Frequency string. fill_value : optional The scalar value to use for newly introduced missing values. .. versionchanged:: 2.1.0 Will raise a ``ValueError`` if ``freq`` is provided too. suffix : str, optional A string to add to each shifted column if there are multiple periods. Ignored otherwise. Returns ------- Series or DataFrame Object shifted within each group. See Also -------- Index.shift : Shift values of Index. Examples -------- For SeriesGroupBy: >>> lst = ["a", "a", "b", "b"] >>> ser = pd.Series([1, 2, 3, 4], index=lst) >>> ser a 1 a 2 b 3 b 4 dtype: int64 >>> ser.groupby(level=0).shift(1) a NaN a 1.0 b NaN b 3.0 dtype: float64 For DataFrameGroupBy: >>> data = [[1, 2, 3], [1, 5, 6], [2, 5, 8], [2, 6, 9]] >>> df = pd.DataFrame( ... data, ... columns=["a", "b", "c"], ... index=["tuna", "salmon", "catfish", "goldfish"], ... ) >>> df a b c tuna 1 2 3 salmon 1 5 6 catfish 2 5 8 goldfish 2 6 9 >>> df.groupby("a").shift(1) b c tuna NaN NaN salmon 2.0 3.0 catfish NaN NaN goldfish 5.0 8.0 r rz0If `periods` is an iterable, it cannot be empty.rTzPeriods must be integer, but z is .z/Cannot specify `suffix` if `periods` is an int.rFNc,|jdS)Nr)shift)r fill_valuefreqperiods rjrzGroupBy.shift..sagg rlrr)r rrr.Series | DataFramer)rr)r1rrrrrr/rrr rr no_defaultrrrrrrrgroup_shift_indexerrrrrrQr> add_suffixr)rhperiodsr r suffixrrshifted_dataframesrsshiftedrr res_indexerrrs `` @rjr z GroupBy.shifts,`  :w/G7|q  !STT 9Jg&3G9DgqQ !RSSE7+,GJ& KFf%3F84V ~QO 44t))5/!%Jmm''--// hhs3xrxx@ ..{C&Q//44K01)#5 gv.":w/?/?/ABG!,,,2vhax(!F8   % %d+?&I JM& KT%&!+ q ! *? rlcr|j}|j|}ddg}|jdk(r$|j|vr|j d}||z S|j j Dcgc] \}}||vs |}}}|r%|j tj|d}||z Scc}}w)a First discrete difference of element. Calculates the difference of each element compared with another element in the group (default is element in previous row). Parameters ---------- periods : int, default 1 Periods to shift for calculating difference, accepts negative values. Returns ------- Series or DataFrame First differences. See Also -------- Series.diff : Apply function diff to a Series. DataFrame.diff : Apply function diff to each row or column of a DataFrame. Examples -------- For SeriesGroupBy: >>> lst = ["a", "a", "a", "b", "b", "b"] >>> ser = pd.Series([7, 2, 8, 4, 3, 3], index=lst) >>> ser a 7 a 2 a 8 b 4 b 3 b 3 dtype: int64 >>> ser.groupby(level=0).diff() a NaN a -5.0 a 6.0 b NaN b -1.0 b 0.0 dtype: float64 For DataFrameGroupBy: >>> data = {"a": [1, 3, 5, 7, 7, 8, 3], "b": [1, 4, 8, 4, 4, 2, 1]} >>> df = pd.DataFrame( ... data, index=["dog", "dog", "dog", "mouse", "mouse", "mouse", "mouse"] ... ) >>> df a b dog 1 1 dog 3 4 dog 5 8 mouse 7 4 mouse 7 4 mouse 8 2 mouse 3 1 >>> df.groupby(level=0).diff() a b dog NaN NaN dog 2.0 3.0 dog 2.0 4.0 mouse NaN NaN mouse 0.0 0.0 mouse 1.0 -2.0 mouse -5.0 -1.0 )rint8int16rfloat32) rr r$rrdtypesitemsdictfromkeys)rhrrr dtypes_to_f32cr to_coerces rjrz GroupBy.diffsT''**W*- ) 88q=yyM)!..3 W} ,/::+;+;+=Xxq%-AWXIX!..y))LMW} Ys 3 B3B3c0|td|d$fd}|j||jdS|jd}|j |j j |j}|j }||z d z S) a Calculate pct_change of each value to previous entry in group. This method calculates the percentage change between the current and a prior element within each group, useful for computing growth rates. Parameters ---------- periods : int, default 1 Periods to shift for calculating percentage change. Comparing with a period of 1 means adjacent elements are compared, whereas a period of 2 compares every other element. fill_method : None Must be None. This argument will be removed in a future version of pandas. freq : str, pandas offset object, or None, default None The frequency increment for time series data (e.g., 'M' for month-end). If None, the frequency is inferred from the index. Relevant for time series data only. Returns ------- Series or DataFrame Percentage changes within each group. See Also -------- Series.pct_change : Apply function pct_change to a Series. DataFrame.pct_change : Apply function pct_change to each row or column of a DataFrame. Examples -------- For SeriesGroupBy: >>> lst = ["a", "a", "b", "b"] >>> ser = pd.Series([1, 2, 3, 4], index=lst) >>> ser a 1 a 2 b 3 b 4 dtype: int64 >>> ser.groupby(level=0).pct_change() a NaN a 1.000000 b NaN b 0.333333 dtype: float64 For DataFrameGroupBy: >>> data = [[1, 2, 3], [1, 5, 6], [2, 5, 8], [2, 6, 9]] >>> df = pd.DataFrame( ... data, ... columns=["a", "b", "c"], ... index=["tuna", "salmon", "catfish", "goldfish"], ... ) >>> df a b c tuna 1 2 3 salmon 1 5 6 catfish 2 5 8 goldfish 2 6 9 >>> df.groupby("a").pct_change() b c tuna NaN NaN salmon 1.5 1.000 catfish NaN NaN goldfish 0.2 0.125 z*fill_method must be None; got fill_method=r c,|jdS)Nr)rr r) pct_change)rr rs rjrz$GroupBy.pct_change..[s!,,'rlTrrr)r)rr r) rr rrrircodesrr )rhr fill_methodr rsfilledfill_grprs ` ` rjr&zGroupBy.pct_changesb  "Jk^1MN N  A --a1C1CRV-W W!$>>$--"5"5$//>R..t.< A%%rlcZ|jtd|}|j|S)a  Return first n rows of each group. Similar to ``.apply(lambda x: x.head(n))``, but it returns a subset of rows from the original DataFrame with original index and order preserved (``as_index`` flag is ignored). Parameters ---------- n : int If positive: number of entries to include from start of each group. If negative: number of entries to exclude from end of each group. Returns ------- Series or DataFrame Subset of original Series or DataFrame as determined by n. See Also -------- Series.head : Apply function head to a Series. DataFrame.head : Apply function head to each row or column of a DataFrame. Examples -------- >>> df = pd.DataFrame([[1, 2], [1, 4], [5, 6]], columns=["A", "B"]) >>> df.groupby("A").head(1) A B 0 1 2 2 5 6 >>> df.groupby("A").head(-1) A B 0 1 2 Nrslicerrhrr+s rjheadz GroupBy.headhs,J66uT1~F&&t,,rlc|r|jt| d}n|jg}|j|S)aI Return last n rows of each group. Similar to ``.apply(lambda x: x.tail(n))``, but it returns a subset of rows from the original DataFrame with original index and order preserved (``as_index`` flag is ignored). Parameters ---------- n : int If positive: number of entries to include from end of each group. If negative: number of entries to exclude from start of each group. Returns ------- Series or DataFrame Subset of original Series or DataFrame as determined by n. See Also -------- Series.tail : Apply function tail to a Series. DataFrame.tail : Apply function tail to each row or column of a DataFrame. Examples -------- >>> df = pd.DataFrame( ... [["a", 1], ["a", 2], ["b", 1], ["b", 2]], columns=["A", "B"] ... ) >>> df.groupby("A").tail(1) A B 1 a 2 3 b 2 >>> df.groupby("A").tail(-1) A B 1 a 2 3 b 2 Nr,r.s rjtailz GroupBy.tailsAP ::5!T?KD::2>D&&t,,rlc\|jj}||dk7z}|j|S)a Return _selected_obj with mask applied. Parameters ---------- mask : np.ndarray[bool] Boolean mask to apply. Returns ------- Series or DataFrame Filtered _selected_obj. r)rrr)rhr+rs rjrzGroupBy._mask_selected_objs2mmsby!!!$''rlcx|jjr |jStj|||}|"tj|j|d}t j |}|jj|j}g} |D]k\} } |j| } t| } ||}n|Jt|| z}tj| |||dn| |}| j| |mtj| }|jj|dS)a Return a random sample of items from each group. You can use `random_state` for reproducibility. Parameters ---------- n : int, optional Number of items to return for each group. Cannot be used with `frac` and must be no larger than the smallest group unless `replace` is True. Default is one if `frac` is None. frac : float, optional Fraction of items to return. Cannot be used with `n`. replace : bool, default False Allow or disallow sampling of the same row more than once. weights : list-like, optional Default None results in equal probability weighting. If passed a list-like then values must have the same length as the underlying DataFrame or Series object and will be used as sampling probabilities after normalization within each group. Values must be non-negative with at least one positive element within each group. random_state : int, array-like, BitGenerator, np.random.RandomState, np.random.Generator, optional If int, array-like, or BitGenerator, seed for random number generator. If np.random.RandomState or np.random.Generator, use as given. Default ``None`` results in sampling with the current state of np.random. Returns ------- Series or DataFrame A new object of same type as caller containing items randomly sampled within each group from the caller object. See Also -------- DataFrame.sample: Generate random samples from a DataFrame object. Series.sample: Generate random samples from a Series object. numpy.random.choice: Generate a random sample from a given 1-D numpy array. Examples -------- >>> df = pd.DataFrame( ... {"a": ["red"] * 2 + ["blue"] * 2 + ["black"] * 2, "b": range(6)} ... ) >>> df a b 0 red 0 1 red 1 2 blue 2 3 blue 3 4 black 4 5 black 5 Select one row at random for each distinct value in column a. The `random_state` argument can be used to guarantee reproducibility: >>> df.groupby("a").sample(n=1, random_state=1) a b 4 black 4 2 blue 2 1 red 1 Set `frac` to sample fixed proportions rather than counts: >>> df.groupby("a")["b"].sample(frac=0.5, random_state=2) 5 5 2 2 0 0 Name: b, dtype: int64 Control sample probabilities within groups by setting weights: >>> df.groupby("a").sample( ... n=1, ... weights=[1, 1, 1, 0, 0, 1], ... random_state=1, ... ) a b 5 black 5 2 blue 2 0 red 0 Nrr)r5replaceweights random_state)rrr;process_sampling_sizepreprocess_weightsrr6rrrrroundrrrr")rhrfracr4r5r6r5 weights_arrgroup_iteratorsampled_indicesr*r grp_indices group_size sample_size grp_sampleconcatenated_sampled_indicess rjr;zGroupBy.samples@x    # #%% %++AtW=   33D4F4FVWXK'' 5 33D4F4FG) .is% )-D $ $% rrz Can't get zZ of an empty group due to unobserved categories. Specify observed=True in groupby instead.Nrz+ with skipna=False encountered an NA value.r)rrr)rrrr?rrr5rrrrE_get_numeric_datar:rr7r) rhrignore_unobservedrr expected_len group_sizes result_lenhas_unobserved raise_errrQrs rjrzGroupBy._idxmax_idxminOsN4}}% 151H1H% " t}}99:L--,,.K$[1_5;;A>J- --',6N->)>)Q>I,,DZi8113D -1   &@@D55::<@@d@Ku$OPQ Q)) % *   rlcF|jj}|jdk(r|j|j}|S|r/|j dj drt|dt|tr|j}|j}t|tjsJt|jd}t|trF|j!|j"j%|d||j|j&}|Si}t)|j*D]&\} } |j"j%| d||| <(|jj!||j }|j,|_|S) Nrrz7 with skipna=True encountered all NA values in a group.F)compatT)rr r)r)rrr5rrltrrrrN to_flat_indexr rrr8rQrwrr"rrBr[r:) rhrrrrrr&rRrQk column_valuess rjrzGroupBy._wrap_idxmax_idxminsr 88q=ZZ ,F4 3q 4 0%NO %,++-[[Ffbjj1 11)%++eDH#v&))KK$$V$R))* (1&(((;$A}#kk..%$8/DG..t399.E!$ rl) NNNNNTTTTT)rrrrrrrops.BaseGrouper | Nonerzfrozenset[Hashable] | Nonerrrrrrrrrrrrrr)rrr)FF)rrrr)rrrrrf)rrrFnpt.NDArray[np.float64] | NonerrE)rrrFrS)r&rrrrr)rQrE)rrrizdict[np.dtype, Any]rjdict[str, bool] | None)rrrr)NF) rsrrQrrz bool | Nonerrrr)rsrrr) rrr&rr$rrrrr)NFr)rrrzCallable | Nonerrrr)F)rrrr)rrrr)T)rrrz np.ndarray)rr)rrrr)rr)FTNN)rrrrr!Literal['cython', 'numba'] | NonerjrT)FT)rrrrrr)rNNFT) rrrrUrjrTrrrr)NFTFT) r>zSequence[Hashable] | Noner?rrrrrrrrr)rFT)rrrrrrrrr)FrTNN) rrrrrrrrUrjrT)FrT)rrrrrrrr)FrTNN)FrT)rrE)NNN)NNNN start_dayNF)rLiteral['right', 'left'] | Noner|rWrz(Literal['start', 'end', 's', 'e'] | Nonerz Level | Nonerzstr | TimestampConvertibleTypesrz TimedeltaConvertibleTypes | Nonerrrrrr_)NFNNNsingle)rz9int | datetime.timedelta | str | BaseOffset | BaseIndexerr  int | Nonerrr str | NonerrZrzIntervalClosedType | Nonerrrrb)rrX)r rrrrr`) NNNNrTFNrX)r float | Nonerr[rzfloat | str | Timedelta | Nonerr[r rYrrrrrznp.ndarray | Series | Nonerrrra)rzLiteral['ffill', 'bfill']rrY)rrY)rrL)rzPositionalIndexer | tuplerzLiteral['any', 'all'] | Nonerr)g?rF)rzfloat | AnyArrayLikerz;Literal['linear', 'lower', 'higher', 'nearest', 'midpoint']rr)rr)averageTrF) rr!rrrr"rrrr)rzint | Sequence[int]rrZ)r)rrrr)rNN)rrr(r))rrrr)r+znpt.NDArray[np.bool_]rr)NNFNN) rrYr:r[r4rr5zListLike | Noner6zRandomState | None)FTF) rLiteral['idxmax', 'idxmin']rFrrrrrrr)rrrr^rrrr)Mrtrrrrrrkrr r/r rIrNrRraror{rrfr rurrrrrrrrrrrrrrrrr&rKrr5r1rarrrur|rrrrrrrrrrrrrrrrrrrrrr rr&r/r1rr;rrrrlrjrrs @DN %)#'*.15'+&O &O"&O! &O ( &O / &O%&O&O&O&O&O&O &O &OP   B "'" >?>? >? >?@ )  2 OS/(/.L/ / /b .2""" +" "P"'" (( (  (    4))+). )V ?C%G %GN ?C% %T9>jHX )-" & & !& & &  &  &  & P N N&-9-9 )-914-9;C-9 -9^  $" >< ><>< ><  >< ><@( -1 < "&d8 8*  :    $ $P  % % <  < | =  = ~ g gR #4804 ggg2 g . g gR `  ` D 4804" vv2v. v  v  v vp 4804" nn2n. n  n  n n` -1 zD)zDzD zD  zD  zD zD zDx HLg g +/g AEg g  g R \ \| #4804 uuu u 2 u . u un MQU  U 58U FJU U  U n #4804 yyy y 2 y . y yv #4804 www w 2 w . w wr NRT  T 58T GKT T  T l NRC  C 58C GKC C  C J q qj !  !F 3715?C2=37 [  %[ 0[ / [ = [  [ 0[ 1[ [ [  [  [ z #'#,0f If  f  f  f  f *f f  f  f P F F F   F  F P !!37""#,0j j j 1 j  j  j j j *j j  (j  j X I IV \0 \0| Q0 Q0f  E( E(T045 $5-5  5n #& " S= S= S=  S= S=j P Pd 6: 6:p '"( Z Z Z  Z  Z  Z  Z x #XNXNXN  XN XNt #XMXMXM  XM XMt #W W W  W  W r #X X X  X  X t () >>! M $M  M  M ^ WW W Wr   a&a&a& a&F %- %-N ,- ,-\ ( ($ !#'+/ zM zMzM zM ! zM ) zM zM~#(" < (< < <  <  <|"=GK rlrct|trddlm}|||||St|trddlm}|||||St d|)am Class for grouping and aggregating relational data. See aggregate, transform, and apply functions on this object. It's easiest to use obj.groupby(...) to use GroupBy, but you can also do: :: grouped = groupby(obj, ...) Parameters ---------- obj : pandas object Returns ------- **Attributes** groups : dict {group name -> group labels} len(grouped) : int Number of groups Notes ----- After grouping, see aggregate, apply, and transform functions. Here are some other brief notes about usage. When grouping by multiple groups, the result index will be a MultiIndex (hierarchical) by default. Iteration produces (key, group) tuples, i.e. chunking the data by group. So you can write code like: :: grouped = obj.groupby(keys) for key, group in grouped: # do something with the data Function calls on GroupBy, if not specially implemented, "dispatch" to the grouped data. So if you group a DataFrame and wish to invoke the std() method on each group, you can simply do: :: df.groupby(mapper).std() rather than :: df.groupby(mapper).aggregate(np.std) You can pass arguments to these "wrapped" functions, too. See the online documentation for full exposition on these topics and much more r) SeriesGroupBy)rrrr)DataFrameGroupByzinvalid type: )rrQpandas.core.groupby.genericr`rErar)rbyrrr`ras rj get_groupbyrdsg~#v=!   C #@!   ..//rlct|}t|dj\}}t||}|jrt d|}g|j |}|jDcgc]}tj||c}tj|t|gz}t||g|jd}|St|} ttj| |} ||g}tj| |tj|| g}t|||jdg}|Scc}w)a Insert the sequence 'qs' of quantiles as the inner-most level of a MultiIndex. The quantile level in the MultiIndex is a repeated copy of 'qs'. Parameters ---------- idx : Index qs : np.ndarray[float64] Returns ------- MultiIndex Fr1rNN)rr'r)rrM factorizer* _is_multirrr'rrErArNrrr) r+rFr lev_codesrHrrr'minidx idx_codess rjrMrMs b'C2E*446NIs$Y4I }}<%#3::#s#,/II6q1c"6"'')SQTX:V9WW vU:LCII:Lt:L M I 3x(4#> s9c*BGGIt,DE vU388T:J K I7s,E)NNT) rrFrcrrrRrrrr)r+rMrFznpt.NDArray[np.float64]rrN)r __future__rcollections.abcrrrrrr r functoolsr r typingr r rrrrrrrrnumpyr pandas._libsrrpandas._libs.algosrpandas._libs.groupby_libsrirpandas._libs.missingrpandas._typingrrrrrrrr r!r"r#pandas.compat.numpyr$r pandas.errorsr%r&r'pandas.util._decoratorsr(pandas.util._exceptionsr)pandas.core.dtypes.castr*r+pandas.core.dtypes.commonr,r-r.r/r0r1r2r3r4r5r6pandas.core.dtypes.missingr7r8r9 pandas.corer:r;pandas.core._numbar<pandas.core.arraysr=r>r?r@pandas.core.arrays.string_rApandas.core.arrays.string_arrowrBpandas.core.baserCrDpandas.core.commoncorecommonrpandas.core.framerEpandas.core.genericrFpandas.core.groupbyrGrHrIpandas.core.groupby.grouperrJpandas.core.groupby.indexingrKrLpandas.core.indexes.apirMrNrOpandas.core.internals.blocksrPpandas.core.seriesrQpandas.core.sortingrRpandas.core.util.numba_rSrTrUpandas._libs.tslibsrVpandas._libs.tslibs.timedeltasrWrXrYrZr[r\r]pandas.core.indexers.objectsr^rr_rr`rarbrdrrrrrrrdrMrrlrjrs*#   '))#    / 34     ( 3<! '' 4 <%6 .89.,@  8nz8#$% 8XJ( )*+h ! " ic,x 8:NcN37C|Nk(#|NB^#&* R0 R0R0$R0 R0  R0jrl